Update pipeline

Closes #336

.cargo-husky/hooks/pre-commit

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo test --all'
+cargo test --all
+echo '+cargo cranky'
+cargo cranky

.cargo-husky/hooks/pre-push

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo cranky'
+cargo cranky

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rs]
+indent_size = 4
+
+[tests/**/*.rs]
+charset = utf-8
+end_of_line = unset
+indent_size = unset
+indent_style = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset

.gitignore

@@ -2,7 +2,10 @@
 vendor.tar.xz
 cargo-config
 .idea
+vendor
 vendor-*
 vendor_*
 .vscode-ctags
-.vscode
+.vscode
+.~lock.*
+*.ods# 

.gitlab-ci.yml

@@ -1,29 +1,84 @@
 image: rust:latest
 
+.rust_cache: &rust_cache
+  cache:
+    # key: $CI_COMMIT_REF_SLUG
+    paths:
+      # Don't include `incremental` to save space
+      # Debug
+      - target/debug/build/
+      - target/debug/deps/
+      - target/debug/.fingerprint/
+      - target/debug/.cargo-lock
+      # Release
+      - target/release/build/
+      - target/release/deps/
+      - target/release/.fingerprint/
+      - target/release/.cargo-lock
+
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev libfontconfig1-dev
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev libsdl2-dev libsdl2-gfx-dev
 
 stages:
-    - test
-    - build
+  - format
+  - check
+  - test
+  - release
+  - deploy
 
-test:
+format:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - echo "nightly" > rust-toolchain
+    - rustup component add rustfmt
+    - cargo fmt --check
+
+check:
+  except:
+    - tags
+  <<: *rust_cache
   script:
     - rustup component add clippy
     - cargo check
-    - cargo clippy
-    - cargo test
+    # deny currently catches too much
+    #- cargo install cargo-deny && cargo deny
+    - cargo install cargo-cranky && cargo cranky
 
-build:
+test:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test --all
+
+release:
   only:
-    - main
+    - tags
+  <<: *rust_cache
   script:
     - make && make vendor
   artifacts:
     paths:
-    - vendor_asus-nb-ctrl_*.tar.xz
+    - vendor_asusctl*.tar.xz
     - cargo-config
 
+pages:
+  stage: deploy
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo doc --document-private-items --no-deps --workspace
+    - rm -rf public
+    - mkdir public
+    - cp -R target/doc/* public
+    - cp extra/index.html public
+  artifacts:
+    paths:
+      - public
+
 variables:
   GIT_SUBMODULE_STRATEGY: normal
-

CHANGELOG.md

@@ -5,13 +5,153 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-## [v4.5.1- RC1]
+## [v4.7.0-RC1]
+### Added
+- Support for FX507Z LED modes
+- Support for GL503V LED modes
+- Support for G733C LED modes
+- Support for GV601VI LED modes
+- Support for G634J LED modes (layout is in progress)
+- Support the Rear Glow on some laptops
+- Support M16 matrix display
+  - Custom images
+  - Pixel gifs
+  - Power options
+  - Builtin animations
+- In-progress simulators for GA402, GU604 animatrix, optional build and takes a single arg
+- Add `model_override` option to anime config, this is handy for forcing a model for "Unknown" anime, and for simulators
+- Add `mini_led_mode` support to asusd and zbus crates (requires kernel patch https://lkml.org/lkml/2023/6/19/1264)
+- Add `mini_led_mode` toggle to rog-control-center GUI, tray, notifications
+### Changed
+- Move FX506HC to FX506H in arua DB to catch full series of this range
+- Move FX506LH to FX506L in arua DB to catch full series of this range
+- Move G513I* to G513I in arua DB to catch full series of this range
+- Remove notification handle tracking limit, fixes KDE issue with profile notif
+- Rename daemon and daemon-user crates to asusd and asusd-user to not be confusing in workspace naming
+- Prevent the multiple notifications from a profile change from occuring (too many functions with side effects!)
+- Apply keyboard brightness when setting a mode
+- Update GL503 led config
+### BREAKING
+- All Anime related DBUS methods/notifs are changed
+
+## [v4.6.2]
+- Fix rog-control-center not reopening if `startup_in_background` is set
+
+## [v4.6.1]
+### Added
+- Support for G733Z LED modes
+- Support for GU604V LED modes
+- Support for GX650P LED modes
+- Support for GV604I LED modes
+- Support for FX516P LED modes (this laptop still has further issues, will require a patched kernel when patch is ready)
+- Add device code for the Z13 ACRNM keyboard (requires kernel patch, in progress)
+- Support for GV301VIC LED modes
+- Add device code for the plain Z13 keyboard (requires kernel patch, in progress)
+- Support for GV301V LED modes
+### Changed
+- Adjustments to Anime system events thread
+- Add "sleep" animetion config options to anime config
+- rog-control-center dark/light mode persistency
+- Adjustments to keyboard detection
+- Better support of using supergfxctl when available (tray icon and menu)
+- Check supergfx version before enabling use in tray (require 5.1.0+)
+- Update allowed Aura modes on asusd restart if changed
+- Set tray icon for dgpu to "On" if in Vfio mode to prevent confusion
+- Add support for Logout/Reboot in notification for KDE
+
+## [v4.6.0]
+### Added
+- Support for GL703GE keyboard layout
+- Support for G533Z modes and keyboard layout
+### Changed
+- Better handling of `/etc/asusd` not existing
+- Better handling of non-existant config files
+- Move all config handling to generic traits for better consistency
+- Re-parse all configs to RON format
+- Move fan-curve config to own config file
+- Added option to set `disable_nvidia_powerd_on_battery`
+- Add short log entry to throttle_thermal_policy change detection
+- ROGCC: Don't notify user if changing to same mux mode
+- ROGCC: Add CLI opt for loading a keyboard layout for testing, with live-reload on file change
+- ROGCC: Add CLI opt for viewing all layout files + filenames to help find a layout matching your laptop
+  + Both of these options would hopefully be temporary and replaced with a "wizard" GUI helper
+- Fix profile controller not detecting if platform_profile is changed
+- Fix remove the leftover initial config writes on `new()` for some controllers to prevent resetting settings on startup
+  + refactor the loading of systemd curve defaults and config file
+### BREAKING
+- Rename aura dbus method from `per_key_raw` to `direct_addressing_raw` and add doc comment
+- Changes to aura.conf:
+- Changes to asusd-ledmodes.toml:
+  + Rename `standard` to `basic_modes`
+  + Rename `multizone` to `basic_zones`
+  + Raname `per_key` to `advanced` and change type from `bool` to `AdvancedAuraType`
+  + Removed `prod_family`
+  + Split all entries to `board_name` (separating `board_names`) (now a huge file)
+  + removed `asusd-ledmodes.toml` in favour of `aura_support.ron` due to an unsupported type in toml
+- Rename and adjust `LedSupportedFunctions` to closely match the above
+
+## [v4.5.8]
+### Changed
+- Fix incorrect stop/start order of nvidia-powerd on AC plug/unplug
+
+## [v4.5.7]
+### Changed
+- ROGCC: Don't notify user if changing to same mux mode
+-
+
+## [v4.5.7]
+### Changed
+- ROGCC: Don't notify user if changing to same mux mode
+- asusd: don't block on systemd-unit change: removes all shoddy external command calls in favour of async dbus calls
+
+## [v4.5.6]
+### Changed
+- Fix tasks not always running correctly on boot/sleep/wake/shutdown by finishing the move to async
+- Change how the profile/fan change task monitors changes due to TUF laptops behaving slightly different
+- ROGCC: Better handle the use of GPU MUX without supergfxd
+- ROGCC: Track if reboot required when not using supergfxd
+- Add env var for logging levels to daemon and gui (`RUST_LOG=<error|warn|info|debug|trace>`)
+- ROGCC: Very basic support for running a command on AC/Battery switching, this is in config at `~/.config/rog/rog-control-center.cfg`, and for now must be edited by hand and ROGCC restarted (run ROGCC in BG to use effectively)
+  + Run ROGCC from terminal to see errors of the AC/Battery command
+  + Support for editing via ROGCC GUI will come in future
+  + This is ideal for userspace tasks
+- asusd: Very basic support for running a command on AC/Battery switching, this is in config at `/etc/asusd/asusd.conf`. A restart of asusd is not required if edited.
+  + This is ideal for tasks that require root access (BE SAFE!)
+- The above AC/Battery commands are probably best set to run a script for more complex tasks
+- asusd: check if nvidia-powerd enabled before toggling
+
+## [v4.5.5]
+### Changed
+- remove an unwrap() causing panic on main ROGCC thread
+
+## [v4.5.4]
+### Changed
+- ROGCC:: Allow ROGCC to run without supergfxd
+- ROGCC: Tray/notifs now reads dGPU status directly via supergfx crate (supergfxd not required)
+- Add rust-toolchain to force minimum rust version
+
+## [v4.5.3]
+### Changed
+- Adjust how fan graph in ROGCC works, deny incorrect graphs
+- Fix to apply the fan curve change in ROGCC to the correct profile
+- Support for G713RS LED modes (Author: Peter Ivanov)
+- Support for G713RM LED modes (Author: maxbachmann)
+- Fix VivoBook detection
+- Update dependencies to get latest winit crate (fixes various small issues)
+
+## [v4.5.2]
+### Changed
+- Update dependencies and bump version
+
+## [v4.5.1]
 ### Added
 - Support for FA506IE LED modes (Author: Herohtar)
 ### Changed
 - Add a basic system tray with dGPU status and gpu mode switch actions
 - Fixup some notifications in ROGCC
 - Add config options for notifications for ROGCC
+- Share states with tray process in ROGCC
+- Share tates with tray process in ROGCC
 
 ## [v4.5.0]
 ### Added
@@ -522,6 +662,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fix small deadlock with awaits
 
-## [1.0.0] - 2020-08-13
-
-- Major fork and refactor to use asus-hid patch for ASUS N-Key device
+## [1.0.0]

Cargo.toml

@@ -1,41 +1,42 @@
 [workspace]
-members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+members = ["asusctl", "asusd", "asusd-user", "config-traits", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center", "simulators"]
+default-members = ["asusctl", "asusd", "asusd-user", "rog-control-center"]
 
 [workspace.package]
-version = "4.5.1-RC1"
+version = "4.7.0-RC1"
 
 [workspace.dependencies]
 async-trait = "^0.1"
-tokio = { version = "^1.21.2", features = ["macros", "rt-multi-thread", "time", "sync"]}
+tokio = { version = "^1.23.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
 concat-idents = "^1.1"
 dirs = "^4.0"
-smol = "^1.2"
+smol = "^1.3"
 
-zbus = "^3.4"
-zbus_macros = "^3.4"
-zvariant = "^3.7"
-zvariant_derive = "^3.7"
-logind-zbus = { version = "^3.0" } #, default-features = false, features = ["non_blocking"] }
+zbus = "~3.13.1"
+logind-zbus = { version = "^3.1.0" } #, default-features = false, features = ["non_blocking"] }
 
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
-toml = "^0.5.9"
+toml = "^0.5.10"
+ron = "*"
 
 log = "^0.4"
-env_logger = "^0.9.3"
+env_logger = "^0.10.0"
 
 glam = { version = "^0.22", features = ["serde"] }
 gumdrop = "^0.8"
-udev = "^0.6"
+udev = "^0.7"
 rusb = "^0.9"
-sysfs-class = "^0.1.2"
+sysfs-class = "^0.1.3"
 inotify = "^0.10.0"
 
 png_pong = "^0.8"
 pix = "^0.13"
-tinybmp = "^0.3"
-gif = "^0.11"
+tinybmp = "^0.4.0"
+gif = "^0.12.0"
+
+versions = "4.1"
 
 notify-rust = { git = "https://github.com/flukejones/notify-rust.git", default-features = false, features = ["z"] }
 
@@ -54,3 +55,8 @@ opt-level = 1
 [profile.bench]
 debug = false
 opt-level = 3
+
+[workspace.dependencies.cargo-husky]
+version = "1"
+default-features = false
+features = ["user-hooks"]

Cranky.toml

@@ -0,0 +1,121 @@
+# https://github.com/ericseppanen/cargo-cranky
+# cargo install cargo-cranky && cargo cranky
+
+error = [
+  "clippy::all",
+  "clippy::await_holding_lock",
+  "clippy::bool_to_int_with_if",
+  "clippy::char_lit_as_u8",
+  "clippy::checked_conversions",
+  "clippy::dbg_macro",
+  "clippy::debug_assert_with_mut_call",
+  "clippy::disallowed_methods",
+  "clippy::disallowed_script_idents",
+  "clippy::doc_link_with_quotes",
+  "clippy::doc_markdown",
+  "clippy::empty_enum",
+  "clippy::enum_glob_use",
+  "clippy::equatable_if_let",
+  "clippy::exit",
+  "clippy::expl_impl_clone_on_copy",
+  "clippy::explicit_deref_methods",
+  "clippy::explicit_into_iter_loop",
+  "clippy::explicit_iter_loop",
+  "clippy::fallible_impl_from",
+  "clippy::filter_map_next",
+  "clippy::flat_map_option",
+  "clippy::float_cmp_const",
+  "clippy::fn_params_excessive_bools",
+  "clippy::fn_to_numeric_cast_any",
+  "clippy::from_iter_instead_of_collect",
+  "clippy::if_let_mutex",
+  "clippy::implicit_clone",
+  "clippy::imprecise_flops",
+  "clippy::index_refutable_slice",
+  "clippy::inefficient_to_string",
+  "clippy::invalid_upcast_comparisons",
+  "clippy::iter_not_returning_iterator",
+  "clippy::iter_on_empty_collections",
+  "clippy::iter_on_single_items",
+  "clippy::large_digit_groups",
+  "clippy::large_stack_arrays",
+  "clippy::large_types_passed_by_value",
+  "clippy::let_unit_value",
+  "clippy::linkedlist",
+  "clippy::lossy_float_literal",
+  "clippy::macro_use_imports",
+  "clippy::manual_assert",
+  "clippy::manual_instant_elapsed",
+  "clippy::manual_ok_or",
+  "clippy::manual_string_new",
+  "clippy::map_err_ignore",
+  "clippy::map_flatten",
+  "clippy::map_unwrap_or",
+  "clippy::match_on_vec_items",
+  "clippy::match_same_arms",
+  "clippy::match_wild_err_arm",
+  "clippy::match_wildcard_for_single_variants",
+  "clippy::mem_forget",
+  "clippy::mismatched_target_os",
+  "clippy::mismatching_type_param_order",
+  "clippy::missing_enforced_import_renames",
+  # "clippy::missing_errors_doc",
+  "clippy::missing_safety_doc",
+  "clippy::mut_mut",
+  "clippy::mutex_integer",
+  "clippy::needless_borrow",
+  "clippy::needless_continue",
+  "clippy::needless_for_each",
+  "clippy::needless_pass_by_value",
+  "clippy::negative_feature_names",
+  "clippy::nonstandard_macro_braces",
+  "clippy::option_option",
+  "clippy::path_buf_push_overwrite",
+  "clippy::ptr_as_ptr",
+  "clippy::rc_mutex",
+  "clippy::ref_option_ref",
+  "clippy::rest_pat_in_fully_bound_structs",
+  "clippy::same_functions_in_if_condition",
+  "clippy::semicolon_if_nothing_returned",
+  "clippy::single_match_else",
+  "clippy::str_to_string",
+  "clippy::string_add_assign",
+  "clippy::string_add",
+  "clippy::string_lit_as_bytes",
+  "clippy::string_to_string",
+  "clippy::todo",
+  "clippy::trailing_empty_array",
+  "clippy::trait_duplication_in_bounds",
+  "clippy::unimplemented",
+  "clippy::unnecessary_wraps",
+  "clippy::unnested_or_patterns",
+  "clippy::unused_peekable",
+  "clippy::unused_rounding",
+  # "clippy::unused_self",
+  "clippy::useless_transmute",
+  "clippy::verbose_file_reads",
+  "clippy::zero_sized_map_values",
+  "elided_lifetimes_in_paths",
+  "future_incompatible",
+  "nonstandard_style",
+  "rust_2018_idioms",
+  "rust_2021_prelude_collisions",
+  "rustdoc::missing_crate_level_docs",
+  "semicolon_in_expressions_from_macros",
+  "trivial_numeric_casts",
+  "unused_extern_crates",
+  "unused_import_braces",
+  "unused_lifetimes",
+]
+
+allow = [
+  # TODO(emilk): enable more lints
+  "clippy::cloned_instead_of_copied",
+  "clippy::derive_partial_eq_without_eq",
+  "clippy::type_complexity",
+  "clippy::undocumented_unsafe_blocks",
+  "trivial_casts",
+  "unsafe_op_in_unsafe_fn",               # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
+  "unused_qualifications",
+]
+

MANUAL.md

@@ -47,35 +47,7 @@ The LED controller (e.g, aura) enables setting many of the factory modes availab
 
 #### Supported laptops
 
-Models GA401, GA502, GU502 support LED brightness change only (no RGB). However the GA401Q model can actually use three modes; static, breathe, and pulse, plus also use red to control the LED brightness intensity.
-
-All models that have any form of LED mode control need to be enabled via the config file at `/etc/asusd/asusd-ledmodes.toml`. Unfortunately ASUS doesn't provide any easy way to find all the supported modes for all laptops (not even through Armory Crate and its various files, that progrma downloads only the required settings for the laptop it runs on) so each model must be added as needed.
-
-#### Config options
-
-The defaults are located at `/etc/asusd/asusd-ledmodes.toml`, and on `asusd` start it creates `/etc/asusd/aura.conf` whcih stores the per-mode settings. If you edit the defaults file you must remove `/etc/asusd/aura.conf` and restart `asusd.service` with `systemctl restart asusd`.
-
-##### /etc/asusd/asusd-ledmodes.toml
-
-Example:
-```toml
-[[led_data]]
-prod_family = "Strix"
-board_names = ["GL504G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
-per_key = false
-```
-
-1. `prod_family`: you can find this in `journalctl -b -u asusd`, or `cat /sys/class/dmi/id/product_name`. It should be copied as written. There can be multiple `led-data` groups of the same `prod_family` with differing `board_names`.
-2. `board_names`: is an array of board names in this product family. Find this in the journal as above or by `cat /sys/class/dmi/id/board_name`.
-3. `standard` are the factory preset modes, the names should corrospond to Armory Crate names
-4. `multizone`: some models have 4 to 7 zones of LED control as shown in the example. If the laptop has no zones then an empty array will suffice.
-5. `per_key`: enable per-key RGB effects. The keyboard must support this or it has no effect.
-
-##### /etc/asusd/aura.conf
-
-This file can be manually edited if desired, but the `asusctl` CLI tool, or dbus methods are the preferred method. Any manual changes to this file mean that the `asusd.service` will need to be restarted, or you need to cycle between modes to force a reload.
+There are over 60 supported laptops as of 01-01-2023. Please see [the rog-aura crate readme for further details](/rog-aura/README.md).
 
 ### Charge control
 
@@ -145,87 +117,100 @@ I'm unsure of how many laptops this works on, so please try it.
 
 An Aura config itself is a file with contents:
 
-```json
-{
-  "name": "aura-default",
-  "aura": [
-    {
-      "Breathe": {
-        "led_type": {
-          "Key": "W"
-        },
-        "start_colour1": [
-          255,
-          0,
-          20
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            Breathe((
+                led: W,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: A,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: S,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: D,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: F,
+                start_colour1: (255, 0, 0),
+                start_colour2: (255, 0, 0),
+                speed: High,
+            )),
+            Static((
+                led: RCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: LCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: Esc,
+                colour: (0, 0, 255),
+            )),
+            DoomFlicker((
+                led: N9,
+                start_colour: (0, 0, 255),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
         ],
-        "start_colour2": [
-          20,
-          255,
-          0
-        ],
-        "speed": "Low"
-      }
-    },
-    {
-      "Static": {
-        "led_type": {
-          "Key": "Esc"
-        },
-        "colour": [
-          0,
-          0,
-          255
-        ]
-      }
-    },
-    {
-      "Flicker": {
-        "led_type": {
-          "Key": "N9"
-        },
-        "start_colour": [
-          0,
-          0,
-          255
-        ],
-        "max_percentage": 80,
-        "min_percentage": 40
-      }
-    }
-  ]
-}
+        zoned: false,
+    ),
+)
 ```
 
-If your laptop supports multizone, `"led_type"` can also be `"Zone": <one of the following>`
-- `"None"`
-- `"KeyboardLeft"`
-- `"KeyboardCenterLeft"`
-- `"KeyboardCenterRight"`
-- `"KeyboardRight"`
-- `"LightbarRight"`
-- `"LightbarRightCorner"`
-- `"LightbarRightBottom"`
-- `"LightbarLeftBottom"`
-- `"LightbarLeftCorner"`
-- `"LightbarLeft"`
+If your laptop supports multizone, `"led"` can also be `"Zone": <one of the following>`
+- `SingleZone` // Keyboards with only one zone
+- `ZonedKbLeft` // keyboard left
+- `ZonedKbLeftMid` // keyboard left-middle
+- `ZonedKbRightMid` // etc
+- `ZonedKbRight`
+- `LightbarRight`
+- `LightbarRightCorner`
+- `LightbarRightBottom`
+- `LightbarLeftBottom`
+- `LightbarLeftCorner`
+- `LightbarLeft`
+
+Single zone example:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            DoomFlicker((
+                led: SingleZone,
+                start_colour: (200, 40, 5),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: true,
+    ),
+)
+```
 
 At the moment there are only three effects available as shown in the example. More will come in the future
 but this may take me some time.
 
-**Aura layouts**: `asusd-user` does its best to find a suitable layout to use based on `/sys/class/dmi/id/board_name`.
-It looks at each of the files in `/usr/share/rog-gui/layouts/` and matches against the toml block looking like:
-```toml
-matches = [
-    'GX502',
-    'GU502',
-]
-```
-
-My laptop is a `GX502GW`, so `GX502` is a match. Note that these layouts are the physical representation of
-the keyboard and are used in the GUI also. The config that tells if per-key is supported is located in
-`/etc/asusd/asusd-ledmodes.toml`
-
 #### Config options: AniMe
 
 `~/.config/rog/rog-user.cfg` contains a setting `"active_anime": "<FILENAME>"` where `<FILENAME>` is the name of the AniMe config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "anime-doom"`

Makefile

@@ -1,4 +1,4 @@
-VERSION := $(shell grep -Pm1 'version = "(\d.\d.\d)"' daemon/Cargo.toml | cut -d'"' -f2)
+VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d.\d.\d)"' Cargo.toml | cut -d'"' -f2)
 
 INSTALL = install
 INSTALL_PROGRAM = ${INSTALL} -D -m 0755
@@ -15,14 +15,19 @@ BIN_ROG := rog-control-center
 BIN_C := asusctl
 BIN_D := asusd
 BIN_U := asusd-user
-LEDCFG := asusd-ledmodes.toml
+LEDCFG := aura_support.ron
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
+STRIP_BINARIES ?= 0
+
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
 	ARGS += --release
 	TARGET = release
+else
+	ARGS += --profile dev
+	TARGET = debug
 endif
 
 VENDORED ?= 0
@@ -38,18 +43,20 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install:
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+install-program:
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+
+install-data:
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
-	cd rog-aura/data/layouts && find . -type f -name "*.toml" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
-
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
 
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
-	$(INSTALL_DATA) "./data/$(LEDCFG)" "$(DESTDIR)/etc/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
 	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 
 	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
@@ -71,6 +78,8 @@ install:
 
 	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
 
+install: install-program install-data
+
 uninstall:
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
 	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
@@ -112,9 +121,12 @@ ifeq ($(VENDORED),1)
 	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
-	strip -s ./target/release/$(BIN_C)
-	strip -s ./target/release/$(BIN_D)
-	strip -s ./target/release/$(BIN_U)
-	strip -s ./target/release/$(BIN_ROG)
+ifneq ($(STRIP_BINARIES),0)
+	strip -s ./target/$(TARGET)/$(BIN_C)
+	strip -s ./target/$(TARGET)/$(BIN_D)
+	strip -s ./target/$(TARGET)/$(BIN_U)
+	strip -s ./target/$(TARGET)/$(BIN_ROG)
+endif
+
 
 .PHONY: all clean distclean install uninstall update build

README.md

@@ -2,7 +2,7 @@
 
 [![](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=4V2DEPS7K6APC) - [Asus Linux Website](https://asus-linux.org/)
 
-**WARNING:** Do not run the main branch of this repo unless you have all the asus-wmi kernel patches. You should use stable kernels + tagged releases.
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel, or v6.1 which has all my work merged upstream.
 
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
@@ -13,6 +13,8 @@ Now includes a GUI, `rog-control-center`.
 
 **The minimum supported kernel version is 5.17**
 
+**For TUF laptops, the minimum supported kernel version is 6.1**
+
 ## Goals
 
 1. To provide an interface for rootless control of some system functions most users wish to control such as fan speeds, keyboard LEDs, graphics modes.
@@ -29,7 +31,7 @@ a system-level daemon should.
 
 ## Discord
 
-[Discord server link](https://discord.gg/4ZKGd7Un5t)
+[Discord server link](https://discord.gg/WTHnqabm)
 
 ## SUPPORTED LAPTOPS
 
@@ -43,8 +45,6 @@ Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 then it may work without tweaks. Technically all other functions except the LED
 and AniMe parts should work regardless of your latop make.
 
-**TUF Laptops**: now supported provided the kernel is patched. These patches are submitted upstream and will be in version 6.1.x of the kernel (or thereabouts). See the blog on asus-linux.org for more info.
-
 ## Implemented
 
 - [X] System daemon
@@ -74,14 +74,24 @@ Requirements are rust >= 1.57 installed from rustup.io if the distro provided ve
 
 **Ubuntu (unsuported):**
 
-    apt install libclang-dev libudev-dev
+    apt install libgtk-3-dev libpango1.0-dev libgdk-pixbuf-2.0-dev libglib2.0-dev cmake libclang-dev libudev-dev libayatana-appindicator3-1
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
     make
     sudo make install
 
+**popos (unsuported):**
+
+    sudo apt install cmake libclang-dev libudev-dev libgtk-3-dev libclang-dev libglib2.0-dev libatkmm-1.6-dev libpangomm-1.4-dev librust-gdk-pixbuf-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
+    make
+    sudo make install
+
+
 **fedora:**
 
-    dnf install cmake clang-devel systemd-devel gtk3-devel
+    dnf install cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf2-devel gtk3-devel libappindicator-gtk3
     make
     sudo make install
 
@@ -90,7 +100,7 @@ Requirements are rust >= 1.57 installed from rustup.io if the distro provided ve
 Works with KDE Plasma (without GTK packages)
 
     zypper in -t pattern devel_basis
-    zypper in rustup cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf-devel gtk3-devel
+    zypper in rustup make cmake systemd-devel clang-devel llvm-devel gdk-pixbuf-devel cairo-devel pango-devel freetype-devel gtk3-devel libexpat-devel libayatana-indicator3-7
     make
     sudo make install
 
@@ -116,6 +126,10 @@ You may also need to activate the service for debian install. If running Pop!_OS
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
+# Contributing
+
+See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
+
 # OTHER
 
 ## Supporting more laptops

asusctl/Cargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "asusctl"
+license = "MPL-2.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2021"
 version.workspace = true
@@ -10,7 +11,7 @@ rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
-daemon = { path = "../daemon" }
+asusd = { path = "../asusd" }
 
 gumdrop.workspace = true
 toml.workspace = true
@@ -21,3 +22,5 @@ gif.workspace = true
 tinybmp.workspace = true
 glam.workspace = true
 rog_dbus = { path = "../rog-dbus" }
+
+cargo-husky.workspace = true

asusctl/examples/anime-diag-png.rs

@@ -1,6 +1,10 @@
-use std::{env, error::Error, path::Path, process::exit};
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {

asusctl/examples/anime-diag.rs

@@ -1,6 +1,8 @@
-use std::{thread::sleep, time::Duration};
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
 use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
@@ -20,7 +22,7 @@ fn main() {
         }
 
         for c in (0..35).into_iter().step_by(step) {
-            for i in matrix.get_mut()[c].iter_mut() {
+            for i in &mut matrix.get_mut()[c] {
                 *i = 50;
             }
         }

asusctl/examples/anime-gif.rs

@@ -1,6 +1,9 @@
-use std::{env, path::Path, thread::sleep};
+use std::env;
+use std::path::Path;
+use std::thread::sleep;
 
-use rog_anime::{usb::get_anime_type, ActionData, ActionLoader, Sequences};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{ActionData, ActionLoader, Sequences};
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() {

asusctl/examples/anime-grid.rs

@@ -1,7 +1,9 @@
-use rog_anime::{usb::get_anime_type, AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClientBlocking;
 use std::convert::TryFrom;
 
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeGrid};
+use rog_dbus::RogDbusClientBlocking;
+
 // In usable data:
 // Top row start at 1, ends at 32
 
@@ -17,7 +19,6 @@ fn main() {
     for (y, row) in tmp.iter_mut().enumerate() {
         if y % 2 == 0 && i + 1 != row.len() - 1 {
             i += 1;
-            dbg!(i);
         }
         row[row.len() - i] = 0x22;
         if i > 5 {

asusctl/examples/anime-outline.rs

@@ -1,4 +1,5 @@
-use rog_anime::{usb::get_anime_type, AnimeDataBuffer};
+use rog_anime::usb::get_anime_type;
+use rog_anime::AnimeDataBuffer;
 use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:

asusctl/examples/anime-png.rs

@@ -1,10 +1,11 @@
 use std::convert::TryFrom;
-use std::{env, error::Error, path::Path, process::exit};
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{
-    usb::get_anime_type,
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {

asusctl/examples/anime-spinning.rs

@@ -1,12 +1,14 @@
 use std::convert::TryFrom;
-use std::{
-    env, error::Error, f32::consts::PI, path::Path, process::exit, thread::sleep, time::Duration,
-};
+use std::env;
+use std::error::Error;
+use std::f32::consts::PI;
+use std::path::Path;
+use std::process::exit;
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{
-    usb::get_anime_type,
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -35,7 +37,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     loop {
         matrix.angle += 0.05;
         if matrix.angle > PI * 2.0 {
-            matrix.angle = 0.0
+            matrix.angle = 0.0;
         }
         matrix.update();
 

asusctl/examples/aura-rgb-ball.rs-

@@ -6,17 +6,17 @@ use rog_aura::{
     KeyColourArray,
 };
 use rog_dbus::RogDbusClientBlocking;
-use std::collections::LinkedList;
+use std::collections::VecDeque;
 
 #[derive(Debug, Clone)]
 struct Ball {
     position: (f32, f32),
     direction: (f32, f32),
-    trail: LinkedList<(f32, f32)>,
+    trail: VecDeque<(f32, f32)>,
 }
 impl Ball {
     fn new(x: f32, y: f32, trail_len: u32) -> Self {
-        let mut trail = LinkedList::new();
+        let mut trail = VecDeque::new();
         for _ in 1..=trail_len {
             trail.push_back((x, y));
         }
@@ -106,7 +106,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 c[2] = 255;
             };
         }
-        dbus.proxies().led().per_key_raw(colours.get())?;
+        dbus.proxies().led().direct_addressing_raw(colours.get())?;
 
         std::thread::sleep(std::time::Duration::from_millis(150));
     }

asusctl/examples/aura-rgb-breathe.rs

@@ -1,59 +0,0 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
-
-use rog_aura::{keys::Key, layouts::KeyLayout, Breathe, Colour, Effect, LedType, Sequences, Speed};
-use rog_dbus::RogDbusClientBlocking;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let layout = KeyLayout::gx502_layout();
-
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-
-    let mut seq = Sequences::new();
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::W),
-        Colour(255, 127, 0),
-        Colour(127, 0, 255),
-        Speed::Med,
-    ));
-
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::A));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::S));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::D));
-    seq.push(key.clone());
-
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::Q),
-        Colour(127, 127, 127),
-        Colour(127, 255, 255),
-        Speed::Low,
-    ));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::E));
-    seq.push(key.clone());
-
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::N1),
-        Colour(166, 127, 166),
-        Colour(127, 155, 20),
-        Speed::High,
-    ));
-    key.set_led_type(LedType::Key(Key::Tilde));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N2));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N3));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N4));
-    seq.push(key.clone());
-
-    loop {
-        seq.next_state(&layout);
-        let packets = seq.create_packets();
-
-        client.proxies().led().per_key_raw(packets)?;
-        std::thread::sleep(std::time::Duration::from_millis(60));
-    }
-}

asusctl/examples/aura-rgb-iterate-keys.rs

@@ -1,34 +0,0 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
-
-use rog_aura::{layouts::KeyLayout, KeyColourArray};
-use rog_dbus::RogDbusClientBlocking;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-    let layout = KeyLayout::gx502_layout();
-    loop {
-        let mut key_colours = KeyColourArray::new();
-        for row in layout.rows() {
-            for (k, key) in row.row().enumerate() {
-                if k != 0 {
-                    if let Some(prev) = row.row().nth(k - 1) {
-                        if let Some(c) = key_colours.rgb_for_key(*prev) {
-                            c[0] = 0;
-                        };
-                    }
-                }
-
-                if key.is_placeholder() {
-                    continue;
-                }
-
-                if let Some(c) = key_colours.rgb_for_key(*key) {
-                    c[0] = 255;
-                };
-
-                client.proxies().led().per_key_raw(key_colours.get())?;
-                std::thread::sleep(std::time::Duration::from_millis(100));
-            }
-        }
-    }
-}

asusctl/examples/aura-zoned-breathe.rs

@@ -1,44 +1,64 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
+//! Using a combination of key-colour array plus a key layout to generate
+//! outputs.
 
-use rog_aura::{layouts::KeyLayout, Breathe, Colour, Effect, LedType, PerZone, Sequences, Speed};
+use rog_aura::advanced::LedCode;
+use rog_aura::effects::{AdvancedEffects, Effect};
+use rog_aura::layouts::KeyLayout;
+use rog_aura::Colour;
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let layout = KeyLayout::gx502_layout();
+    let layout = KeyLayout::default_layout();
 
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let mut seq = Sequences::new();
+    let mut seq = AdvancedEffects::new(true);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::KeyboardLeft),
-        Colour(166, 127, 166),
-        Colour(127, 155, 20),
-        Speed::High,
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::Single,
+    //     Colour(166, 127, 166),
+    //     Colour(127, 155, 20),
+    //     rog_aura::Speed::High,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::DoomLightFlash(rog_aura::effects::DoomLightFlash::new(
+    //     RgbAddress::Single,
+    //     Colour(200, 0, 0),
+    //     80,
+    //     10,
+    // ));
+    // seq.push(zone);
+
+    let zone = Effect::DoomFlicker(rog_aura::effects::DoomFlicker::new(
+        LedCode::SingleZone,
+        Colour(200, 110, 0),
+        100,
+        10,
     ));
     seq.push(zone);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::KeyboardCenterLeft),
-        Colour(16, 127, 255),
-        Colour(127, 15, 20),
-        Speed::Low,
-    ));
-    seq.push(zone);
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::KeyboardCenterLeft,
+    //     Colour(16, 127, 255),
+    //     Colour(127, 15, 20),
+    //     rog_aura::Speed::Low,
+    // ));
+    // seq.push(zone);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::LightbarRightCorner),
-        Colour(0, 255, 255),
-        Colour(255, 0, 255),
-        Speed::Med,
-    ));
-    seq.push(zone);
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::LightbarRightCorner,
+    //     Colour(0, 255, 255),
+    //     Colour(255, 0, 255),
+    //     rog_aura::Speed::Med,
+    // ));
+    // seq.push(zone);
 
     loop {
         seq.next_state(&layout);
         let packets = seq.create_packets();
 
-        client.proxies().led().per_key_raw(packets)?;
-        std::thread::sleep(std::time::Duration::from_millis(60));
+        client.proxies().led().direct_addressing_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(33));
     }
 }

asusctl/src/anime_cli.rs

@@ -1,21 +1,24 @@
 use gumdrop::Options;
+use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
+use rog_anime::AnimeType;
 
 #[derive(Options)]
 pub struct AnimeCommand {
     #[options(help = "print help message")]
     pub help: bool,
+    #[options(meta = "", help = "override the display type")]
+    pub override_type: Option<AnimeType>,
+    #[options(meta = "", help = "enable/disable the display")]
+    pub enable_display: Option<bool>,
+    #[options(meta = "", help = "enable/disable the builtin run/powersave animation")]
+    pub enable_powersave_anim: Option<bool>,
     #[options(
         meta = "",
-        help = "enable/disable the panel LEDs (does not erase last image)"
+        help = "set global base brightness value <Off, Low, Med, High>"
     )]
-    pub enable: Option<bool>,
-    #[options(
-        meta = "",
-        help = "enable/disable system animations (boot/sleep/shutdown)"
-    )]
-    pub boot_enable: Option<bool>,
-    #[options(meta = "", help = "set global AniMe brightness value")]
-    pub brightness: Option<f32>,
+    pub brightness: Option<Brightness>,
+    #[options(meta = "", help = "set global (image) brightness value")]
+    pub image_brightness: Option<f32>,
     #[options(help = "clear the display")]
     pub clear: bool,
     #[options(command)]
@@ -32,6 +35,24 @@ pub enum AnimeActions {
     Gif(AnimeGif),
     #[options(help = "display an animated diagonal/pixel-perfect GIF")]
     PixelGif(AnimeGifDiagonal),
+    #[options(help = "change which builtin animations are shown")]
+    SetBuiltins(Builtins),
+}
+
+#[derive(Options)]
+pub struct Builtins {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = " <GlitchConstruction, StaticEmergence>")]
+    pub boot: AnimBooting,
+    #[options(meta = "", help = "<BinaryBannerScroll, RogLogoGlitch>")]
+    pub awake: AnimAwake,
+    #[options(meta = "", help = "<BannerSwipe, Starfield>")]
+    pub sleep: AnimSleeping,
+    #[options(meta = "", help = "<GlitchOut, SeeYa>")]
+    pub shutdown: AnimShutdown,
+    #[options(meta = "", help = "set/apply the animations")]
+    pub set: Option<bool>,
 }
 
 #[derive(Options)]

asusctl/src/aura_cli.rs

@@ -1,7 +1,9 @@
-use gumdrop::Options;
-use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 use std::str::FromStr;
 
+use gumdrop::Options;
+use rog_aura::error::Error;
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
+
 #[derive(Options)]
 pub struct LedPowerCommand1 {
     #[options(help = "print help message")]
@@ -29,13 +31,19 @@ pub struct LedPowerCommand2 {
 #[derive(Options)]
 pub enum SetAuraEnabled {
     /// Applies to both old and new models
-    #[options(help = "set <keyboard, logo, lightbar> to enabled while device is awake")]
+    #[options(help = "set <keyboard, logo, lightbar, rearglow> to enabled while device is awake")]
     Awake(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to enabled while the device is booting")]
+    #[options(
+        help = "set <keyboard, logo, lightbar, rearglow> to enabled while the device is booting"
+    )]
     Boot(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is suspended")]
+    #[options(
+        help = "set <keyboard, logo, lightbar, rearglow> to animate while the device is suspended"
+    )]
     Sleep(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is shutdown")]
+    #[options(
+        help = "set <keyboard, logo, lightbar, rearglow> to animate while the device is shutdown"
+    )]
     Shutdown(AuraEnabled),
 }
 
@@ -48,7 +56,9 @@ pub struct AuraEnabled {
     #[options(meta = "", help = "<true/false>")]
     pub logo: Option<bool>,
     #[options(meta = "", help = "<true/false>")]
-    pub lightbar: Option<bool>,
+    pub frontglow: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub rearglow: Option<bool>,
     #[options(meta = "", help = "<true/false>")]
     pub lid: Option<bool>,
 }
@@ -105,7 +115,7 @@ impl ToString for LedBrightness {
             Some(0x02) => "high",
             _ => "unknown",
         };
-        s.to_string()
+        s.to_owned()
     }
 }
 
@@ -220,7 +230,6 @@ pub struct MultiColourSpeed {
 /// Byte value for setting the built-in mode.
 ///
 /// Enum corresponds to the required integer value
-///
 // NOTE: The option names here must match those in rog-aura crate
 #[derive(Options)]
 pub enum SetAuraBuiltin {

asusctl/src/cli_opts.rs

@@ -1,10 +1,9 @@
-use crate::{
-    anime_cli::AnimeCommand,
-    aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin},
-    profiles_cli::{FanCurveCommand, ProfileCommand},
-};
 use gumdrop::Options;
 
+use crate::anime_cli::AnimeCommand;
+use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
+use crate::profiles_cli::{FanCurveCommand, ProfileCommand};
+
 #[derive(Default, Options)]
 pub struct CliStart {
     #[options(help_flag, help = "print help message")]
@@ -71,7 +70,7 @@ pub struct BiosCommand {
         meta = "",
         short = "S",
         no_long,
-        help = "set bios POST sound: asusctl -p <true/false>"
+        help = "set bios POST sound: asusctl -S <true/false>"
     )]
     pub post_sound_set: Option<bool>,
     #[options(no_long, short = "s", help = "read bios POST sound")]

asusctl/src/main.rs

@@ -1,17 +1,16 @@
 use std::convert::TryFrom;
+use std::env::args;
+use std::path::Path;
 use std::process::Command;
 use std::thread::sleep;
-use std::{env::args, path::Path};
-
-use aura_cli::{LedPowerCommand1, LedPowerCommand2};
-use gumdrop::{Opt, Options};
 
 use anime_cli::{AnimeActions, AnimeCommand};
+use aura_cli::{LedPowerCommand1, LedPowerCommand2};
+use gumdrop::{Opt, Options};
 use profiles_cli::{FanCurveCommand, ProfileCommand};
 use rog_anime::usb::get_anime_type;
-use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
-
-use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
+use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
 use rog_aura::{self, AuraEffect};
 use rog_dbus::RogDbusClientBlocking;
 use rog_platform::platform::GpuMode;
@@ -26,7 +25,7 @@ mod aura_cli;
 mod cli_opts;
 mod profiles_cli;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() {
     let args: Vec<String> = args().skip(1).collect();
 
     let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
@@ -37,73 +36,52 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             ..Default::default()
         },
         Err(err) => {
-            eprintln!("source {}", err);
-            std::process::exit(2);
+            println!("Error: {}", err);
+            return;
         }
     };
 
-    let (dbus, _) = RogDbusClientBlocking::new()
-        .map_err(|e| {
-            print_error_help(Box::new(e), None);
-            std::process::exit(3);
-        })
-        .unwrap();
+    if let Ok((dbus, _)) = RogDbusClientBlocking::new().map_err(|e| {
+        print_error_help(&e, None);
+    }) {
+        if let Ok(supported) = dbus
+            .proxies()
+            .supported()
+            .supported_functions()
+            .map_err(|e| {
+                print_error_help(&e, None);
+            })
+        {
+            if parsed.version {
+                println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+                println!();
+                print_info();
+            }
 
-    let supported = dbus
-        .proxies()
-        .supported()
-        .supported_functions()
-        .map_err(|e| {
-            print_error_help(Box::new(e), None);
-            std::process::exit(4);
-        })
-        .unwrap();
-
-    if parsed.version {
-        print_versions();
-        println!();
-        print_laptop_info();
-        return Ok(());
+            if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
+                print_error_help(&*err, Some(&supported));
+            }
+        }
     }
-
-    if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
-        print_error_help(err, Some(&supported));
-    }
-
-    Ok(())
 }
 
-fn print_error_help(err: Box<dyn std::error::Error>, supported: Option<&SupportedFunctions>) {
+fn print_error_help(err: &dyn std::error::Error, supported: Option<&SupportedFunctions>) {
     check_service("asusd");
     println!("\nError: {}\n", err);
-    print_versions();
-    println!();
-    print_laptop_info();
+    print_info();
     if let Some(supported) = supported {
         println!();
         println!("Supported laptop functions:\n\n{}", supported);
     }
 }
 
-fn print_versions() {
-    println!("App and daemon versions:");
-    println!("      asusctl v{}", env!("CARGO_PKG_VERSION"));
-    println!("        asusd v{}", daemon::VERSION);
-    println!("\nComponent crate versions:");
-    println!("    rog-anime v{}", rog_anime::VERSION);
-    println!("     rog-aura v{}", rog_aura::VERSION);
-    println!("     rog-dbus v{}", rog_dbus::VERSION);
-    println!(" rog-profiles v{}", rog_profiles::VERSION);
-    println!("rog-platform v{}", rog_platform::VERSION);
-}
-
-fn print_laptop_info() {
+fn print_info() {
     let dmi = sysfs_class::DmiId::default();
     let board_name = dmi.board_name().expect("Could not get board_name");
     let prod_family = dmi.product_family().expect("Could not get product_family");
-
-    println!("Product family: {}", prod_family.trim());
-    println!("Board name: {}", board_name.trim());
+    println!("asusctl version: {}", env!("CARGO_PKG_VERSION"));
+    println!(" Product family: {}", prod_family.trim());
+    println!("     Board name: {}", board_name.trim());
 }
 
 fn check_service(name: &str) -> bool {
@@ -126,7 +104,7 @@ fn check_service(name: &str) -> bool {
 fn do_parsed(
     parsed: &CliStart,
     supported: &SupportedFunctions,
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
         Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
@@ -134,9 +112,9 @@ fn do_parsed(
         Some(CliCommand::LedPow2(pow)) => handle_led_power2(dbus, &supported.keyboard_led, pow)?,
         Some(CliCommand::Profile(cmd)) => handle_profile(dbus, &supported.platform_profile, cmd)?,
         Some(CliCommand::FanCurve(cmd)) => {
-            handle_fan_curve(dbus, &supported.platform_profile, cmd)?
+            handle_fan_curve(dbus, &supported.platform_profile, cmd)?;
         }
-        Some(CliCommand::Graphics(_)) => do_gfx()?,
+        Some(CliCommand::Graphics(_)) => do_gfx(),
         Some(CliCommand::Anime(cmd)) => handle_anime(dbus, &supported.anime_ctrl, cmd)?,
         Some(CliCommand::Bios(cmd)) => handle_bios_option(dbus, &supported.rog_bios_ctrl, cmd)?,
         None => {
@@ -150,10 +128,10 @@ fn do_parsed(
                 println!("{}", CliStart::usage());
                 println!();
                 if let Some(cmdlist) = CliStart::command_list() {
-                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
                     for command in commands.iter().filter(|command| {
                         if !matches!(
-                            supported.keyboard_led.prod_id,
+                            supported.keyboard_led.dev_id,
                             AuraDevice::X1854
                                 | AuraDevice::X1869
                                 | AuraDevice::X1866
@@ -162,7 +140,7 @@ fn do_parsed(
                         {
                             return false;
                         }
-                        if supported.keyboard_led.prod_id != AuraDevice::X19B6
+                        if supported.keyboard_led.dev_id != AuraDevice::X19b6
                             && command.trim().starts_with("led-pow-2")
                         {
                             return false;
@@ -214,21 +192,25 @@ fn do_parsed(
     Ok(())
 }
 
-fn do_gfx() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Please use supergfxctl for graphics switching. supergfxctl is the result of making asusctl graphics switching generic so all laptops can use it");
+fn do_gfx() {
+    println!(
+        "Please use supergfxctl for graphics switching. supergfxctl is the result of making \
+         asusctl graphics switching generic so all laptops can use it"
+    );
     println!("This command will be removed in future");
-    Ok(())
 }
 
 fn handle_anime(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     _supported: &AnimeSupportedFunctions,
     cmd: &AnimeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if (cmd.command.is_none()
-        && cmd.enable.is_none()
-        && cmd.boot_enable.is_none()
-        && cmd.brightness.is_none())
+        && cmd.enable_display.is_none()
+        && cmd.enable_powersave_anim.is_none()
+        && cmd.brightness.is_none()
+        && cmd.image_brightness.is_none()
+        && !cmd.clear)
         || cmd.help
     {
         println!("Missing arg or command\n\n{}", cmd.self_usage());
@@ -236,25 +218,34 @@ fn handle_anime(
             println!("\n{}", lst);
         }
     }
-    if let Some(anime_turn) = cmd.enable {
-        dbus.proxies().anime().set_on_off(anime_turn)?
+    if let Some(enable) = cmd.enable_display {
+        dbus.proxies().anime().set_enable_display(enable)?;
     }
-    if let Some(anime_boot) = cmd.boot_enable {
-        dbus.proxies().anime().set_boot_on_off(anime_boot)?
+    if let Some(enable) = cmd.enable_powersave_anim {
+        dbus.proxies().anime().set_builtins_enabled(enable)?;
     }
     if let Some(bright) = cmd.brightness {
-        verify_brightness(bright);
-        dbus.proxies().anime().set_brightness(bright)?
+        dbus.proxies().anime().set_brightness(bright)?;
     }
+    if let Some(bright) = cmd.image_brightness {
+        verify_brightness(bright);
+        dbus.proxies().anime().set_image_brightness(bright)?;
+    }
+
+    let mut anime_type = get_anime_type()?;
+    if let AnimeType::Unknown = anime_type {
+        if let Some(model) = cmd.override_type {
+            anime_type = model;
+        }
+    }
+
     if cmd.clear {
-        let anime_type = get_anime_type()?;
-        let data = vec![0u8; anime_type.data_length()];
+        let data = vec![255u8; anime_type.data_length()];
         let tmp = AnimeDataBuffer::from_vec(anime_type, data)?;
         dbus.proxies().anime().write(tmp)?;
     }
 
     if let Some(action) = cmd.command.as_ref() {
-        let anime_type = get_anime_type()?;
         match action {
             AnimeActions::Image(image) => {
                 if image.help_requested() || image.path.is_empty() {
@@ -262,7 +253,7 @@ fn handle_anime(
                     if let Some(lst) = image.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(image.bright);
 
@@ -285,7 +276,7 @@ fn handle_anime(
                     if let Some(lst) = image.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(image.bright);
 
@@ -306,7 +297,7 @@ fn handle_anime(
                     if let Some(lst) = gif.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(gif.bright);
 
@@ -340,7 +331,7 @@ fn handle_anime(
                     if let Some(lst) = gif.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(gif.bright);
 
@@ -365,6 +356,23 @@ fn handle_anime(
                     }
                 }
             }
+            AnimeActions::SetBuiltins(builtins) => {
+                if builtins.help_requested() || builtins.set.is_none() {
+                    println!("\nAny unspecified args will be set to default (first shown var)\n");
+                    println!("\n{}", builtins.self_usage());
+                    if let Some(lst) = builtins.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+
+                dbus.proxies().anime().set_builtin_animations(
+                    builtins.boot,
+                    builtins.awake,
+                    builtins.sleep,
+                    builtins.shutdown,
+                )?;
+            }
         }
     }
     Ok(())
@@ -376,12 +384,11 @@ fn verify_brightness(brightness: f32) {
             "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
             brightness
         );
-        std::process::exit(1);
     }
 }
 
 fn handle_led_mode(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &LedSupportedFunctions,
     mode: &LedModeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -393,9 +400,9 @@ fn handle_led_mode(
         println!("Commands available");
 
         if let Some(cmdlist) = LedModeCommand::command_list() {
-            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
             for command in commands.iter().filter(|command| {
-                for mode in &supported.stock_led_modes {
+                for mode in &supported.basic_modes {
                     if command
                         .trim()
                         .starts_with(&<&str>::from(mode).to_lowercase())
@@ -403,7 +410,7 @@ fn handle_led_mode(
                         return true;
                     }
                 }
-                if !supported.multizone_led_mode.is_empty() && command.trim().starts_with("multi") {
+                if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
                     return true;
                 }
                 false
@@ -438,7 +445,7 @@ fn handle_led_mode(
 }
 
 fn handle_led_power1(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &LedSupportedFunctions,
     power: &LedPowerCommand1,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -456,14 +463,14 @@ fn handle_led_power1(
     }
 
     if matches!(
-        supported.prod_id,
+        supported.dev_id,
         AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866
     ) {
         handle_led_power_1_do_1866(dbus, power)?;
         return Ok(());
     }
 
-    if matches!(supported.prod_id, AuraDevice::Tuf) {
+    if matches!(supported.dev_id, AuraDevice::Tuf) {
         handle_led_power_1_do_tuf(dbus, power)?;
         return Ok(());
     }
@@ -473,13 +480,13 @@ fn handle_led_power1(
 }
 
 fn handle_led_power_1_do_1866(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     power: &LedPowerCommand1,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let mut enabled: Vec<AuraDev1866> = Vec::new();
-    let mut disabled: Vec<AuraDev1866> = Vec::new();
+    let mut enabled: Vec<AuraDevRog1> = Vec::new();
+    let mut disabled: Vec<AuraDevRog1> = Vec::new();
 
-    let mut check = |e: Option<bool>, a: AuraDev1866| {
+    let mut check = |e: Option<bool>, a: AuraDevRog1| {
         if let Some(arg) = e {
             if arg {
                 enabled.push(a);
@@ -489,11 +496,11 @@ fn handle_led_power_1_do_1866(
         }
     };
 
-    check(power.awake, AuraDev1866::Awake);
-    check(power.boot, AuraDev1866::Boot);
-    check(power.sleep, AuraDev1866::Sleep);
-    check(power.keyboard, AuraDev1866::Keyboard);
-    check(power.lightbar, AuraDev1866::Lightbar);
+    check(power.awake, AuraDevRog1::Awake);
+    check(power.boot, AuraDevRog1::Boot);
+    check(power.sleep, AuraDevRog1::Sleep);
+    check(power.keyboard, AuraDevRog1::Keyboard);
+    check(power.lightbar, AuraDevRog1::Lightbar);
 
     let data = AuraPowerDev {
         x1866: enabled,
@@ -513,7 +520,7 @@ fn handle_led_power_1_do_1866(
 }
 
 fn handle_led_power_1_do_tuf(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     power: &LedPowerCommand1,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let mut enabled: Vec<AuraDevTuf> = Vec::new();
@@ -539,7 +546,6 @@ fn handle_led_power_1_do_tuf(
         x19b6: vec![],
         tuf: enabled,
     };
-    dbg!(&data);
     dbus.proxies().led().set_leds_power(data, true)?;
 
     let data = AuraPowerDev {
@@ -553,7 +559,7 @@ fn handle_led_power_1_do_tuf(
 }
 
 fn handle_led_power2(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &LedSupportedFunctions,
     power: &LedPowerCommand2,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -565,8 +571,8 @@ fn handle_led_power2(
         println!("Commands available");
 
         if let Some(cmdlist) = LedPowerCommand2::command_list() {
-            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
-            for command in commands.iter() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+            for command in &commands {
                 println!("{}", command);
             }
         }
@@ -581,13 +587,13 @@ fn handle_led_power2(
             return Ok(());
         }
 
-        if supported.prod_id != AuraDevice::X19B6 {
-            println!("This option applies only to keyboards with product ID 0x19b6")
+        if supported.dev_id != AuraDevice::X19b6 {
+            println!("This option applies only to keyboards with product ID 0x19b6");
         }
 
-        let mut enabled: Vec<AuraDev19b6> = Vec::new();
-        let mut disabled: Vec<AuraDev19b6> = Vec::new();
-        let mut check = |e: Option<bool>, a: AuraDev19b6| {
+        let mut enabled: Vec<AuraDevRog2> = Vec::new();
+        let mut disabled: Vec<AuraDevRog2> = Vec::new();
+        let mut check = |e: Option<bool>, a: AuraDevRog2| {
             if let Some(arg) = e {
                 if arg {
                     enabled.push(a);
@@ -599,28 +605,32 @@ fn handle_led_power2(
 
         match pow {
             aura_cli::SetAuraEnabled::Boot(arg) => {
-                check(arg.keyboard, AuraDev19b6::BootKeyb);
-                check(arg.logo, AuraDev19b6::BootLogo);
-                check(arg.lightbar, AuraDev19b6::BootBar);
-                check(arg.lid, AuraDev19b6::AwakeLid);
+                check(arg.keyboard, AuraDevRog2::BootKeyb);
+                check(arg.logo, AuraDevRog2::BootLogo);
+                check(arg.frontglow, AuraDevRog2::BootBar);
+                check(arg.rearglow, AuraDevRog2::BootRearGlow);
+                check(arg.lid, AuraDevRog2::AwakeLid);
             }
             aura_cli::SetAuraEnabled::Sleep(arg) => {
-                check(arg.keyboard, AuraDev19b6::SleepKeyb);
-                check(arg.logo, AuraDev19b6::SleepLogo);
-                check(arg.lightbar, AuraDev19b6::SleepBar);
-                check(arg.lid, AuraDev19b6::SleepLid);
+                check(arg.keyboard, AuraDevRog2::SleepKeyb);
+                check(arg.logo, AuraDevRog2::SleepLogo);
+                check(arg.frontglow, AuraDevRog2::SleepBar);
+                check(arg.rearglow, AuraDevRog2::SleepRearGlow);
+                check(arg.lid, AuraDevRog2::SleepLid);
             }
             aura_cli::SetAuraEnabled::Awake(arg) => {
-                check(arg.keyboard, AuraDev19b6::AwakeKeyb);
-                check(arg.logo, AuraDev19b6::AwakeLogo);
-                check(arg.lightbar, AuraDev19b6::AwakeBar);
-                check(arg.lid, AuraDev19b6::AwakeLid);
+                check(arg.keyboard, AuraDevRog2::AwakeKeyb);
+                check(arg.logo, AuraDevRog2::AwakeLogo);
+                check(arg.frontglow, AuraDevRog2::AwakeBar);
+                check(arg.rearglow, AuraDevRog2::AwakeRearGlow);
+                check(arg.lid, AuraDevRog2::AwakeLid);
             }
             aura_cli::SetAuraEnabled::Shutdown(arg) => {
-                check(arg.keyboard, AuraDev19b6::ShutdownKeyb);
-                check(arg.logo, AuraDev19b6::ShutdownLogo);
-                check(arg.lightbar, AuraDev19b6::ShutdownBar);
-                check(arg.lid, AuraDev19b6::ShutdownBar);
+                check(arg.keyboard, AuraDevRog2::ShutdownKeyb);
+                check(arg.logo, AuraDevRog2::ShutdownLogo);
+                check(arg.frontglow, AuraDevRog2::ShutdownBar);
+                check(arg.rearglow, AuraDevRog2::ShutdownRearGlow);
+                check(arg.lid, AuraDevRog2::ShutdownLid);
             }
         }
 
@@ -647,7 +657,7 @@ fn handle_led_power2(
 }
 
 fn handle_profile(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &PlatformProfileFunctions,
     cmd: &ProfileCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -665,7 +675,7 @@ fn handle_profile(
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-        std::process::exit(1);
+        return Ok(());
     }
 
     if cmd.next {
@@ -676,7 +686,9 @@ fn handle_profile(
 
     if cmd.list {
         let res = dbus.proxies().profile().profiles()?;
-        res.iter().for_each(|p| println!("{:?}", p));
+        for p in &res {
+            println!("{:?}", p);
+        }
     }
 
     if cmd.profile_get {
@@ -688,7 +700,7 @@ fn handle_profile(
 }
 
 fn handle_fan_curve(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &PlatformProfileFunctions,
     cmd: &FanCurveCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -707,14 +719,14 @@ fn handle_fan_curve(
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-        std::process::exit(1);
+        return Ok(());
     }
 
     if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some())
         && cmd.mod_profile.is_none()
     {
         println!("--enabled, --fan, and --data options require --mod-profile");
-        std::process::exit(666);
+        return Ok(());
     }
 
     if cmd.get_enabled {
@@ -750,7 +762,7 @@ fn handle_fan_curve(
 }
 
 fn handle_bios_option(
-    dbus: &RogDbusClientBlocking,
+    dbus: &RogDbusClientBlocking<'_>,
     supported: &RogBiosSupportedFunctions,
     cmd: &BiosCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -765,10 +777,7 @@ fn handle_bios_option(
         {
             println!("Missing arg or command\n");
 
-            let usage: Vec<String> = BiosCommand::usage()
-                .lines()
-                .map(|s| s.to_string())
-                .collect();
+            let usage: Vec<String> = BiosCommand::usage().lines().map(|s| s.to_owned()).collect();
 
             for line in usage.iter().filter(|line| {
                 line.contains("sound") && supported.post_sound
@@ -792,7 +801,10 @@ fn handle_bios_option(
             dbus.proxies()
                 .rog_bios()
                 .set_gpu_mux_mode(GpuMode::from_mux(opt))?;
-            println!("The mode change is not active until you reboot, on boot the bios will make the required change");
+            println!(
+                "The mode change is not active until you reboot, on boot the bios will make the \
+                 required change"
+            );
         }
         if cmd.gpu_mux_mode_get {
             let res = dbus.proxies().rog_bios().gpu_mux_mode()?;

asusctl/src/profiles_cli.rs

@@ -1,5 +1,6 @@
 use gumdrop::Options;
-use rog_profiles::{fan_curve_set::CurveData, FanCurvePU, Profile};
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{FanCurvePU, Profile};
 
 #[derive(Debug, Clone, Options)]
 pub struct ProfileCommand {

asusd-user/Cargo.toml

@@ -1,14 +1,11 @@
 [package]
-name = "daemon-user"
+name = "asusd-user"
+license = "MPL-2.0"
 version.workspace = true
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2021"
 description = "Usermode daemon for user settings, anime, per-key lighting"
 
-[lib]
-name = "rog_user"
-path = "src/lib.rs"
-
 [[bin]]
 name = "asusd-user"
 path = "src/daemon.rs"
@@ -26,7 +23,13 @@ rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_platform = { path = "../rog-platform" }
+config-traits = { path = "../config-traits" }
 
 zbus.workspace = true
-zvariant.workspace = true
-zvariant_derive.workspace = true
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

asusd-user/src/config.rs

@@ -0,0 +1,219 @@
+use std::path::PathBuf;
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences as AnimeSequences, Vec2};
+use rog_aura::advanced::LedCode;
+use rog_aura::effects::{AdvancedEffects as AuraSequences, Breathe, DoomFlicker, Effect, Static};
+use rog_aura::{Colour, Speed};
+use serde_derive::{Deserialize, Serialize};
+
+use crate::error::Error;
+
+const ROOT_CONF_DIR: &str = "rog";
+
+fn root_conf_dir() -> PathBuf {
+    let mut dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+    dir.push(ROOT_CONF_DIR);
+    dir
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAnime {
+    pub name: String,
+    pub anime: Vec<ActionLoader>,
+}
+
+impl ConfigAnime {
+    pub fn create(&self, anime_type: AnimeType) -> Result<AnimeSequences, Error> {
+        let mut seq = AnimeSequences::new(anime_type);
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAnime {
+    fn default() -> Self {
+        Self {
+            name: "anime-default".to_owned(),
+            anime: vec![
+                ActionLoader::AsusImage {
+                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        None,
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::AsusAnimation {
+                    file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(6),
+                        None,
+                        Duration::from_secs(3),
+                    )),
+                },
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::Image {
+                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
+                    scale: 1.0,
+                    angle: 0.0,
+                    translation: Vec2::default(),
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(1)),
+                        Duration::from_secs(2),
+                    )),
+                    brightness: 0.6,
+                },
+                ActionLoader::Pause(Duration::from_secs(1)),
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                    scale: 0.9,
+                    angle: 0.0,
+                    translation: Vec2::new(3.0, 2.0),
+                    brightness: 0.5,
+                    time: AnimTime::Count(2),
+                },
+            ],
+        }
+    }
+}
+
+impl StdConfig for ConfigAnime {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAnime {}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAura {
+    pub name: String,
+    pub aura: AuraSequences,
+}
+
+impl ConfigAura {
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAura {
+    fn default() -> Self {
+        let mut seq = AuraSequences::new(false);
+        let mut key = Effect::Breathe(Breathe::new(
+            LedCode::W,
+            Colour(255, 0, 20),
+            Colour(20, 255, 0),
+            Speed::Low,
+        ));
+
+        seq.push(key.clone());
+        key.set_led(LedCode::A);
+        seq.push(key.clone());
+        key.set_led(LedCode::S);
+        seq.push(key.clone());
+        key.set_led(LedCode::D);
+        seq.push(key);
+
+        let key = Effect::Breathe(Breathe::new(
+            LedCode::F,
+            Colour(255, 0, 0),
+            Colour(255, 0, 0),
+            Speed::High,
+        ));
+        seq.push(key);
+
+        let mut key = Effect::Static(Static::new(LedCode::RCtrl, Colour(0, 0, 255)));
+        seq.push(key.clone());
+        key.set_led(LedCode::LCtrl);
+        seq.push(key.clone());
+        key.set_led(LedCode::Esc);
+        seq.push(key);
+
+        let key = Effect::DoomFlicker(DoomFlicker::new(LedCode::N9, Colour(0, 0, 255), 80, 40));
+        seq.push(key);
+
+        Self {
+            name: "aura-default".to_owned(),
+            aura: seq,
+        }
+    }
+}
+
+impl StdConfig for ConfigAura {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAura {}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ConfigBase {
+    /// Name of active anime config file in the user config directory
+    pub active_anime: Option<String>,
+    /// Name of active aura config file in the user config directory
+    pub active_aura: Option<String>,
+}
+
+impl StdConfig for ConfigBase {
+    fn new() -> Self {
+        Self {
+            active_anime: Some("anime-default".to_owned()),
+            active_aura: Some("aura-default".to_owned()),
+        }
+    }
+
+    fn file_name(&self) -> String {
+        "rog-user.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigBase {}

asusd-user/src/ctrl_anime.rs

@@ -1,27 +1,25 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use config_traits::StdConfig;
 use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
 use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
-use std::time::Duration;
-use std::{
-    path::Path,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Mutex,
-    },
-};
-use std::{sync::Arc, thread::sleep, time::Instant};
 use zbus::dbus_interface;
-use zvariant::ObjectPath;
-use zvariant_derive::Type;
+use zbus::zvariant::{ObjectPath, Type};
 
-use crate::user_config::ConfigLoadSave;
-use crate::{error::Error, user_config::UserAnimeConfig};
+use crate::config::ConfigAnime;
+use crate::error::Error;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
 pub struct Timer {
     type_of: TimeType,
-    /// If time type is Timer then this is milliseonds, otherwise it is animation loop count
+    /// If time type is Timer then this is milliseonds, otherwise it is
+    /// animation loop count
     count: u64,
     /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
     fade_in: Option<u64>,
@@ -63,8 +61,8 @@ pub enum TimeType {
     Infinite,
 }
 
-/// The inner object exists to allow the zbus proxy to share it with a runner thread
-/// and a zbus server behind `Arc<Mutex<T>>`
+/// The inner object exists to allow the zbus proxy to share it with a runner
+/// thread and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
     client: RogDbusClientBlocking<'a>,
@@ -83,7 +81,9 @@ impl<'a> CtrlAnimeInner<'static> {
             do_early_return,
         })
     }
-    /// To be called on each main loop iteration to pump out commands to the anime
+
+    /// To be called on each main loop iteration to pump out commands to the
+    /// anime
     pub fn run(&'a self) -> Result<(), Error> {
         if self.do_early_return.load(Ordering::SeqCst) {
             return Ok(());
@@ -102,7 +102,7 @@ impl<'a> CtrlAnimeInner<'static> {
                             .write(output)
                             .map_err(|e| AnimeError::Dbus(format!("{}", e)))
                             .map(|_| false)
-                    })?;
+                    });
                 }
                 ActionData::Image(image) => {
                     self.client
@@ -123,10 +123,10 @@ impl<'a> CtrlAnimeInner<'static> {
                         sleep(Duration::from_millis(1));
                     }
                 }
-                ActionData::AudioEq => {}
-                ActionData::SystemInfo => {}
-                ActionData::TimeDate => {}
-                ActionData::Matrix => {}
+                ActionData::AudioEq
+                | ActionData::SystemInfo
+                | ActionData::TimeDate
+                | ActionData::Matrix => {}
             }
         }
 
@@ -135,16 +135,16 @@ impl<'a> CtrlAnimeInner<'static> {
 }
 
 pub struct CtrlAnime<'a> {
-    config: Arc<Mutex<UserAnimeConfig>>,
+    config: Arc<Mutex<ConfigAnime>>,
     client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
 }
 
-impl<'a> CtrlAnime<'static> {
+impl CtrlAnime<'static> {
     pub fn new(
-        config: Arc<Mutex<UserAnimeConfig>>,
+        config: Arc<Mutex<ConfigAnime>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
         client: RogDbusClientBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
@@ -184,7 +184,7 @@ impl CtrlAnime<'static> {
     pub fn insert_asus_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         time: Timer,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
@@ -207,7 +207,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
 
@@ -222,7 +222,7 @@ impl CtrlAnime<'static> {
     pub fn insert_image_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
@@ -252,7 +252,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -268,7 +268,7 @@ impl CtrlAnime<'static> {
     pub fn insert_image(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
@@ -297,7 +297,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -322,7 +322,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -345,7 +345,7 @@ impl CtrlAnime<'static> {
             if (index as usize) < config.anime.len() {
                 config.anime.remove(index as usize);
             }
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -360,13 +360,13 @@ impl CtrlAnime<'static> {
     pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
         // Operations here need to be in specific order
         if on {
-            self.client.proxies().anime().set_on_off(on).ok();
+            self.client.proxies().anime().set_enable_display(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().set_on_off(on).ok();
+            self.client.proxies().anime().set_enable_display(on).ok();
         }
         Ok(())
     }

asusd-user/src/daemon.rs

@@ -1,18 +1,19 @@
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use asusd_user::config::*;
+use asusd_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
+use asusd_user::DBUS_NAME;
+use config_traits::{StdConfig, StdConfigLoad};
 use rog_anime::usb::get_anime_type;
+use rog_aura::aura_detection::LaptopLedData;
 use rog_aura::layouts::KeyLayout;
 use rog_dbus::RogDbusClientBlocking;
-use rog_user::{
-    ctrl_anime::{CtrlAnime, CtrlAnimeInner},
-    user_config::*,
-    DBUS_NAME,
-};
 use smol::Executor;
-use std::sync::Mutex;
-use std::{fs::OpenOptions, io::Read, path::PathBuf, sync::Arc};
 use zbus::Connection;
 
-use std::sync::atomic::AtomicBool;
-
 #[cfg(not(feature = "local_data"))]
 const DATA_DIR: &str = "/usr/share/rog-gui/";
 #[cfg(feature = "local_data")]
@@ -20,7 +21,14 @@ const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("  user daemon v{}", rog_user::VERSION);
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .init();
+
+    println!("  user daemon v{}", asusd_user::VERSION);
     println!("    rog-anime v{}", rog_anime::VERSION);
     println!("     rog-dbus v{}", rog_dbus::VERSION);
     println!("rog-platform v{}", rog_platform::VERSION);
@@ -28,8 +36,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (client, _) = RogDbusClientBlocking::new()?;
     let supported = client.proxies().supported().supported_functions()?;
 
-    let mut config = UserConfig::new();
-    config.load()?;
+    let config = ConfigBase::new().load();
 
     let executor = Executor::new();
 
@@ -38,7 +45,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     if supported.anime_ctrl.0 {
         if let Some(cfg) = config.active_anime {
             let anime_type = get_anime_type()?;
-            let anime_config = UserAnimeConfig::load(cfg)?;
+            let anime_config = ConfigAnime::new().set_name(cfg).load();
             let anime = anime_config.create(anime_type)?;
             let anime_config = Arc::new(Mutex::new(anime_config));
 
@@ -69,24 +76,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // if supported.keyboard_led.per_key_led_mode {
     if let Some(cfg) = config.active_aura {
-        let mut aura_config = UserAuraConfig::load(cfg)?;
+        let mut aura_config = ConfigAura::new().set_name(cfg).load();
+        // let baord_name = std::fs::read_to_string(BOARD_NAME)?;
 
-        // Find and load a matching layout for laptop
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(PathBuf::from(BOARD_NAME))
-            .map_err(|e| {
-                println!("{BOARD_NAME}, {e}");
-                e
-            })?;
-        let mut board_name = String::new();
-        file.read_to_string(&mut board_name)?;
+        let led_support = LaptopLedData::get_data();
 
-        let layout = KeyLayout::find_layout(board_name.as_str(), PathBuf::from(DATA_DIR))
+        let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
             .map_err(|e| {
                 println!("{BOARD_NAME}, {e}");
             })
-            .unwrap_or_else(|_| KeyLayout::ga401_layout());
+            .unwrap_or_else(|_| KeyLayout::default_layout());
 
         executor
             .spawn(async move {
@@ -99,7 +98,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     aura_config.aura.next_state(&layout);
                     let packets = aura_config.aura.create_packets();
 
-                    client.proxies().led().per_key_raw(packets).unwrap();
+                    client
+                        .proxies()
+                        .led()
+                        .direct_addressing_raw(packets)
+                        .unwrap();
                     std::thread::sleep(std::time::Duration::from_millis(33));
                 }
             })

asusd-user/src/error.rs

@@ -13,7 +13,7 @@ pub enum Error {
 
 impl fmt::Display for Error {
     // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::Io(err) => write!(f, "Failed to open: {}", err),
             Error::ConfigLoadFail => write!(f, "Failed to load user config"),

asusd-user/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod user_config;
+pub mod config;
 
 pub mod error;
 

asusd-user/src/zbus_anime.rs

@@ -1,7 +1,8 @@
-//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//! # `DBus` interface proxy for: `org.asuslinux.Daemon`
 //!
-//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
-//! Source: `Interface '/org/asuslinux/Anime' from service 'org.asuslinux.Daemon' on session bus`.
+//! This code was generated by `zbus-xmlgen` `1.0.0` from `DBus` introspection
+//! data. Source: `Interface '/org/asuslinux/Anime' from service
+//! 'org.asuslinux.Daemon' on session bus`.
 //!
 //! You may prefer to adapt it, instead of using it verbatim.
 //!
@@ -9,8 +10,8 @@
 //! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
 //! section of the zbus documentation.
 //!
-//! This DBus object implements
-//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! This `DBus` object implements
+//! [standard `DBus` interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
 //! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
 //!
 //! * [`zbus::fdo::PeerProxy`]

asusd/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
-name = "daemon"
-version.workspace = true
+name = "asusd"
 license = "MPL-2.0"
+version.workspace = true
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
@@ -9,15 +9,12 @@ homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
 edition = "2021"
 
-[lib]
-name = "daemon"
-path = "src/lib.rs"
-
 [[bin]]
 name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
+config-traits = { path = "../config-traits" }
 rog_anime = { path = "../rog-anime", features = ["dbus"] }
 rog_aura = { path = "../rog-aura", features = ["dbus"] }
 rog_platform = { path = "../rog-platform" }
@@ -32,16 +29,18 @@ log.workspace = true
 env_logger.workspace = true
 
 zbus.workspace = true
-zvariant.workspace = true
 logind-zbus.workspace = true
 
 # serialisation
 serde.workspace = true
 serde_derive.workspace = true
-serde_json.workspace = true
-toml.workspace = true
 
 # Device control
 sysfs-class.workspace = true # used for backlight control and baord ID
 
-concat-idents.workspace = true
+concat-idents.workspace = true
+
+systemd-zbus = "*"
+
+[dev-dependencies]
+cargo-husky.workspace = true

asusd/src/config.rs

@@ -0,0 +1,83 @@
+use config_traits::{StdConfig, StdConfigLoad2};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+#[derive(Deserialize, Serialize, Default, Debug)]
+pub struct Config {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            bat_charge_limit: 100,
+            panel_od: false,
+            mini_led_mode: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad2<Config458, Config462> for Config {}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config462 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config462> for Config {
+    fn from(c: Config462) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            mini_led_mode: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config458 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config458> for Config {
+    fn from(c: Config458) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            mini_led_mode: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+        }
+    }
+}

asusd/src/ctrl_anime/config.rs

@@ -0,0 +1,216 @@
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad2};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::Brightness;
+use rog_anime::{ActionData, ActionLoader, AnimTime, Animations, AnimeType, Fade, Vec2};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "anime.ron";
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV460 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+}
+
+impl From<AnimeConfigV460> for AnimeConfig {
+    fn from(c: AnimeConfigV460) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            sleep: c.sleep,
+            shutdown: c.shutdown,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AnimeConfigV5 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+    pub awake_enabled: bool,
+    pub boot_anim_enabled: bool,
+}
+
+impl From<AnimeConfigV5> for AnimeConfig {
+    fn from(c: AnimeConfigV5) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            sleep: c.sleep,
+            shutdown: c.shutdown,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct AnimeConfigCached {
+    pub system: Vec<ActionData>,
+    pub boot: Vec<ActionData>,
+    pub wake: Vec<ActionData>,
+    pub sleep: Vec<ActionData>,
+    pub shutdown: Vec<ActionData>,
+}
+
+impl AnimeConfigCached {
+    pub fn init_from_config(
+        &mut self,
+        config: &AnimeConfig,
+        anime_type: AnimeType,
+    ) -> Result<(), AnimeError> {
+        let mut sys = Vec::with_capacity(config.system.len());
+        for ani in &config.system {
+            sys.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.system = sys;
+
+        let mut boot = Vec::with_capacity(config.boot.len());
+        for ani in &config.boot {
+            boot.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.boot = boot;
+
+        let mut wake = Vec::with_capacity(config.wake.len());
+        for ani in &config.wake {
+            wake.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.wake = wake;
+
+        let mut sleep = Vec::with_capacity(config.sleep.len());
+        for ani in &config.sleep {
+            sleep.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.sleep = sleep;
+
+        let mut shutdown = Vec::with_capacity(config.shutdown.len());
+        for ani in &config.shutdown {
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.shutdown = shutdown;
+        Ok(())
+    }
+}
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AnimeConfig {
+    pub model_override: Option<AnimeType>,
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
+}
+
+impl Default for AnimeConfig {
+    fn default() -> Self {
+        AnimeConfig {
+            model_override: None,
+            system: Vec::new(),
+            boot: Vec::new(),
+            wake: Vec::new(),
+            sleep: Vec::new(),
+            shutdown: Vec::new(),
+            brightness: 1.0,
+            display_enabled: true,
+            display_brightness: Brightness::Med,
+            builtin_anims_enabled: true,
+            builtin_anims: Animations::default(),
+        }
+    }
+}
+
+impl StdConfig for AnimeConfig {
+    fn new() -> Self {
+        Self::create_default()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV5> for AnimeConfig {}
+
+impl AnimeConfig {
+    // fn clamp_config_brightness(mut config: &mut AnimeConfig) {
+    //     if config.brightness < 0.0 || config.brightness > 1.0 {
+    //         warn!(
+    //             "Clamped brightness to [0.0 ; 1.0], was {}",
+    //             config.brightness
+    //         );
+    //         config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
+    //     }
+    // }
+
+    fn create_default() -> Self {
+        // create a default config here
+        AnimeConfig {
+            system: vec![],
+            boot: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            wake: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            sleep: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                scale: 0.9,
+                angle: 0.0,
+                translation: Vec2::new(3.0, 2.0),
+                brightness: 1.0,
+                time: AnimTime::Infinite,
+            }],
+            shutdown: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                scale: 0.9,
+                angle: 0.0,
+                translation: Vec2::new(3.0, 2.0),
+                brightness: 1.0,
+                time: AnimTime::Infinite,
+            }],
+            brightness: 1.0,
+            ..Default::default()
+        }
+    }
+}

asusd/src/ctrl_anime/mod.rs

@@ -1,19 +1,24 @@
 pub mod config;
-/// Implements CtrlTask, Reloadable, ZbusRun
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
 pub mod trait_impls;
 
-use self::config::{AnimeConfig, AnimeConfigCached};
-use crate::{error::RogError, GetSupported};
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread::sleep;
+
 use ::zbus::export::futures_util::lock::Mutex;
 use log::{error, info, warn};
-use rog_anime::{
-    error::AnimeError,
-    usb::{get_anime_type, pkt_for_flush, pkts_for_init},
-    ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
-};
-use rog_platform::{hid_raw::HidRaw, supported::AnimeSupportedFunctions, usb_raw::USBRaw};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::{convert::TryFrom, error::Error, sync::Arc, thread::sleep};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::{get_anime_type, pkt_flush, pkt_set_enable_powersave_anim, pkts_for_init};
+use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::supported::AnimeSupportedFunctions;
+use rog_platform::usb_raw::USBRaw;
+
+use self::config::{AnimeConfig, AnimeConfigCached};
+use crate::error::RogError;
+use crate::GetSupported;
 
 impl GetSupported for CtrlAnime {
     type A = AnimeSupportedFunctions;
@@ -23,8 +28,29 @@ impl GetSupported for CtrlAnime {
     }
 }
 
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
+
+impl Node {
+    pub fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        // TODO: map and pass on errors
+        match self {
+            Node::Usb(u) => {
+                u.write_bytes(message).ok();
+            }
+            Node::Hid(h) => {
+                h.write_bytes(message).ok();
+            }
+        }
+        Ok(())
+    }
+}
+
 pub struct CtrlAnime {
-    node: USBRaw,
+    // node: HidRaw,
+    node: Node,
     anime_type: AnimeType,
     cache: AnimeConfigCached,
     config: AnimeConfig,
@@ -36,11 +62,27 @@ pub struct CtrlAnime {
 
 impl CtrlAnime {
     #[inline]
-    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
-        let node = USBRaw::new(0x193b)?;
-        let anime_type = get_anime_type()?;
+    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, RogError> {
+        // let node = HidRaw::new("193b")?;
+        let usb = USBRaw::new(0x193b).ok();
+        let hid = HidRaw::new("193b").ok();
+        let node = if usb.is_some() {
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            unsafe { Node::Hid(hid.unwrap_unchecked()) }
+        } else {
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        };
 
-        info!("Device has an AniMe Matrix display");
+        let mut anime_type = get_anime_type()?;
+        if let AnimeType::Unknown = anime_type {
+            if let Some(model) = config.model_override {
+                warn!("Overriding the Animatrix type as {model:?}");
+                anime_type = model;
+            }
+        }
+
+        info!("Device has an AniMe Matrix display: {anime_type:?}");
         let mut cache = AnimeConfigCached::default();
         cache.init_from_config(&config, anime_type)?;
 
@@ -56,26 +98,39 @@ impl CtrlAnime {
 
         Ok(ctrl)
     }
+
     // let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
 
-    /// Start an action thread. This is classed as a singleton and there should be only
-    /// one running - so the thread uses atomics to signal run/exit.
+    /// Start an action thread. This is classed as a singleton and there should
+    /// be only one running - so the thread uses atomics to signal run/exit.
     ///
-    /// Because this also writes to the usb device, other write tries (display only) *must*
-    /// get the mutex lock and set the thread_exit atomic.
-    fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
+    /// Because this also writes to the usb device, other write tries (display
+    /// only) *must* get the mutex lock and set the `thread_exit` atomic.
+    async fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
         if actions.is_empty() {
             warn!("AniMe system actions was empty");
             return;
         }
 
-        // Loop rules:
-        // - Lock the mutex **only when required**. That is, the lock must be held for the shortest duration possible.
-        // - An AtomicBool used for thread exit should be checked in every loop, including nested
+        if let Some(lock) = inner.try_lock() {
+            lock.node
+                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                .map_err(|err| {
+                    warn!("rog_anime::run_animation:callback {}", err);
+                })
+                .ok();
+        }
 
-        // The only reason for this outer thread is to prevent blocking while waiting for the
-        // next spawned thread to exit
-        // TODO: turn this in to async task (maybe? COuld still risk blocking main thread)
+        // Loop rules:
+        // - Lock the mutex **only when required**. That is, the lock must be held for
+        //   the shortest duration possible.
+        // - An AtomicBool used for thread exit should be checked in every loop,
+        //   including nested
+
+        // The only reason for this outer thread is to prevent blocking while waiting
+        // for the next spawned thread to exit
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main
+        // thread)
         std::thread::Builder::new()
             .name("AniMe system thread start".into())
             .spawn(move || {
@@ -103,18 +158,17 @@ impl CtrlAnime {
 
                 info!("AniMe no previous system thread running (now)");
                 thread_exit.store(false, Ordering::SeqCst);
-
+                thread_running.store(true, Ordering::SeqCst);
                 'main: loop {
-                    thread_running.store(true, Ordering::SeqCst);
-                    for action in actions.iter() {
+                    for action in &actions {
                         if thread_exit.load(Ordering::SeqCst) {
                             break 'main;
                         }
                         match action {
                             ActionData::Animation(frames) => {
-                                if let Err(err) = rog_anime::run_animation(frames, &|frame| {
+                                rog_anime::run_animation(frames, &|frame| {
                                     if thread_exit.load(Ordering::Acquire) {
-                                        info!("rog-anime: frame-loop was asked to exit");
+                                        info!("rog-anime: animation sub-loop was asked to exit");
                                         return Ok(true); // Do safe exit
                                     }
                                     inner
@@ -130,15 +184,18 @@ impl CtrlAnime {
                                                 .ok();
                                             false // Don't exit yet
                                         })
-                                        .map(Ok)
-                                        .unwrap_or_else(|| {
-                                            warn!("rog_anime::run_animation:callback failed");
-                                            Err(AnimeError::NoFrames)
-                                        })
-                                }) {
-                                    warn!("rog_anime::run_animation:Animation {}", err);
+                                        .map_or_else(
+                                            || {
+                                                warn!("rog_anime::run_animation:callback failed");
+                                                Err(AnimeError::NoFrames)
+                                            },
+                                            Ok,
+                                        )
+                                });
+                                if thread_exit.load(Ordering::Acquire) {
+                                    info!("rog-anime: sub-loop exited and main loop exiting now");
                                     break 'main;
-                                };
+                                }
                             }
                             ActionData::Image(image) => {
                                 once = false;
@@ -149,10 +206,10 @@ impl CtrlAnime {
                                 }
                             }
                             ActionData::Pause(duration) => sleep(*duration),
-                            ActionData::AudioEq => {}
-                            ActionData::SystemInfo => {}
-                            ActionData::TimeDate => {}
-                            ActionData::Matrix => {}
+                            ActionData::AudioEq
+                            | ActionData::SystemInfo
+                            | ActionData::TimeDate
+                            | ActionData::Matrix => {}
                         }
                     }
                     if thread_exit.load(Ordering::SeqCst) {
@@ -194,10 +251,10 @@ impl CtrlAnime {
             *led = bright as u8;
         }
         let data = AnimePacketType::try_from(buffer)?;
-        for row in data.iter() {
+        for row in &data {
             self.node.write_bytes(row)?;
         }
-        self.node.write_bytes(&pkt_for_flush())?;
+        self.node.write_bytes(&pkt_flush())?;
         Ok(())
     }
 

asusd/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,299 @@
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::warn;
+use rog_anime::usb::{
+    pkt_set_brightness, pkt_set_builtin_animations, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness,
+};
+use rog_anime::{AnimeDataBuffer, DeviceState};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use super::CtrlAnime;
+use crate::error::RogError;
+
+pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Anime";
+
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
+
+/// The struct with the main dbus methods requires this trait
+#[async_trait]
+impl crate::ZbusRun for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not
+// grab it until we finish.
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until
+    /// it is restarted
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        let lock = self.0.lock().await;
+        lock.thread_exit.store(true, Ordering::SeqCst);
+        lock.write_data_buffer(input).map_err(|err| {
+            warn!("rog_anime::run_animation:callback {}", err);
+            err
+        })?;
+        Ok(())
+    }
+
+    /// Set the global AniMe brightness
+    async fn set_image_brightness(&self, bright: f32) {
+        let mut lock = self.0.lock().await;
+        let mut bright = bright;
+        if bright < 0.0 {
+            bright = 0.0;
+        } else if bright > 1.0 {
+            bright = 1.0;
+        }
+        lock.config.brightness = bright;
+        lock.config.write();
+    }
+
+    /// Set base brightness level
+    // TODO: enum for brightness
+    async fn set_brightness(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        brightness: Brightness,
+    ) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_brightness(brightness))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.display_brightness = brightness;
+        lock.config.write();
+
+        Self::notify_device_state(
+            &ctxt,
+            DeviceState {
+                display_enabled: lock.config.display_enabled,
+                display_brightness: lock.config.display_brightness,
+                builtin_anims_enabled: lock.config.builtin_anims_enabled,
+                builtin_anims: lock.config.builtin_anims,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// Enable the builtin animations or not
+    async fn set_builtins_enabled(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_enable_powersave_anim(enabled))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.builtin_anims_enabled = enabled;
+        lock.config.write();
+        if enabled {
+            lock.thread_exit.store(true, Ordering::Release);
+        }
+
+        Self::notify_device_state(
+            &ctxt,
+            DeviceState {
+                display_enabled: lock.config.display_enabled,
+                display_brightness: lock.config.display_brightness,
+                builtin_anims_enabled: lock.config.builtin_anims_enabled,
+                builtin_anims: lock.config.builtin_anims,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// Set which builtin animation is used for each stage
+    async fn set_builtin_animations(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        boot: AnimBooting,
+        awake: AnimAwake,
+        sleep: AnimSleeping,
+        shutdown: AnimShutdown,
+    ) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_enable_powersave_anim(true))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&pkt_set_builtin_animations(boot, awake, sleep, shutdown))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.builtin_anims.boot = boot;
+        lock.config.builtin_anims.sleep = sleep;
+        lock.config.builtin_anims.awake = awake;
+        lock.config.builtin_anims.shutdown = shutdown;
+        lock.config.write();
+
+        Self::notify_device_state(
+            &ctxt,
+            DeviceState {
+                display_enabled: lock.config.display_enabled,
+                display_brightness: lock.config.display_brightness,
+                builtin_anims_enabled: lock.config.builtin_anims_enabled,
+                builtin_anims: lock.config.builtin_anims,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// Set whether the AniMe is enabled at all
+    async fn set_enable_display(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_enable_display(enabled))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.display_enabled = enabled;
+        lock.config.write();
+
+        Self::notify_device_state(
+            &ctxt,
+            DeviceState {
+                display_enabled: lock.config.display_enabled,
+                display_brightness: lock.config.display_brightness,
+                builtin_anims_enabled: lock.config.builtin_anims_enabled,
+                builtin_anims: lock.config.builtin_anims,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// The main loop is the base system set action if the user isn't running
+    /// the user daemon
+    async fn run_main_loop(&self, start: bool) {
+        if start {
+            let lock = self.0.lock().await;
+            lock.thread_exit.store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false).await;
+        }
+    }
+
+    /// Get the device state as stored by asusd
+    // #[dbus_interface(property)]
+    async fn device_state(&self) -> DeviceState {
+        let lock = self.0.lock().await;
+        DeviceState {
+            display_enabled: lock.config.display_enabled,
+            display_brightness: lock.config.display_brightness,
+            builtin_anims_enabled: lock.config.builtin_anims_enabled,
+            builtin_anims: lock.config.builtin_anims,
+        }
+    }
+
+    /// Notify listeners of the status of AniMe LED power and factory
+    /// system-status animations
+    #[dbus_interface(signal)]
+    async fn notify_device_state(ctxt: &SignalContext<'_>, data: DeviceState) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            move || {
+                // on_sleep
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    CtrlAnime::run_thread(inner1.clone(), lock.cache.sleep.clone(), true).await;
+                }
+            },
+            move || {
+                // on_wake
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    CtrlAnime::run_thread(inner2.clone(), lock.cache.wake.clone(), true).await;
+                }
+            },
+            move || {
+                // on_shutdown
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    CtrlAnime::run_thread(inner3.clone(), lock.cache.shutdown.clone(), true).await;
+                }
+            },
+            move || {
+                // on_boot
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    CtrlAnime::run_thread(inner4.clone(), lock.cache.boot.clone(), true).await;
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlAnimeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
+            let anim = &lock.config.builtin_anims;
+            lock.node
+                .write_bytes(&pkt_set_enable_display(lock.config.display_enabled))?;
+            lock.node.write_bytes(&pkt_set_enable_powersave_anim(
+                lock.config.builtin_anims_enabled,
+            ))?;
+            lock.node.write_bytes(&pkt_set_builtin_animations(
+                anim.boot,
+                anim.awake,
+                anim.sleep,
+                anim.shutdown,
+            ))?;
+
+            if lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() {
+                lock.node
+                    .write_bytes(&pkt_set_enable_powersave_anim(false))
+                    .ok();
+            }
+            let action = lock.cache.boot.clone();
+            CtrlAnime::run_thread(self.0.clone(), action, true).await;
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_aura/config.rs

@@ -1,15 +1,12 @@
-use crate::laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
-use log::{error, warn};
-use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
-use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
-use rog_platform::hid_raw::HidRaw;
-use rog_platform::keyboard_led::KeyboardLed;
-use serde_derive::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashSet};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
 
-pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_aura::aura_detection::LaptopLedData;
+use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "aura.ron";
 
 /// Enable/disable LED control in various states such as
 /// when the device is awake, suspended, shutting down or
@@ -17,22 +14,22 @@ pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum AuraPowerConfig {
     AuraDevTuf(HashSet<AuraDevTuf>),
-    AuraDev1866(HashSet<AuraDev1866>),
-    AuraDev19b6(HashSet<AuraDev19b6>),
+    AuraDevRog1(HashSet<AuraDevRog1>),
+    AuraDevRog2(HashSet<AuraDevRog2>),
 }
 
 impl AuraPowerConfig {
     /// Invalid for TUF laptops
-    pub fn to_bytes(control: &Self) -> [u8; 3] {
+    pub fn to_bytes(control: &Self) -> [u8; 4] {
         match control {
-            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
-            AuraPowerConfig::AuraDev1866(c) => {
-                let c: Vec<AuraDev1866> = c.iter().copied().collect();
-                AuraDev1866::to_bytes(&c)
+            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0, 0],
+            AuraPowerConfig::AuraDevRog1(c) => {
+                let c: Vec<AuraDevRog1> = c.iter().copied().collect();
+                AuraDevRog1::to_bytes(&c)
             }
-            AuraPowerConfig::AuraDev19b6(c) => {
-                let c: Vec<AuraDev19b6> = c.iter().copied().collect();
-                AuraDev19b6::to_bytes(&c)
+            AuraPowerConfig::AuraDevRog2(c) => {
+                let c: Vec<AuraDevRog2> = c.iter().copied().collect();
+                AuraDevRog2::to_bytes(&c)
             }
         }
     }
@@ -48,13 +45,13 @@ impl AuraPowerConfig {
             ]);
         }
 
-        if let Self::AuraDev1866(c) = control {
+        if let Self::AuraDevRog1(c) = control {
             return Some([
                 true,
-                c.contains(&AuraDev1866::Boot),
-                c.contains(&AuraDev1866::Awake),
-                c.contains(&AuraDev1866::Sleep),
-                c.contains(&AuraDev1866::Keyboard),
+                c.contains(&AuraDevRog1::Boot),
+                c.contains(&AuraDevRog1::Awake),
+                c.contains(&AuraDevRog1::Sleep),
+                c.contains(&AuraDevRog1::Keyboard),
             ]);
         }
 
@@ -70,8 +67,9 @@ impl AuraPowerConfig {
             }
         }
     }
-    pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) {
-        if let Self::AuraDev1866(p) = self {
+
+    pub fn set_0x1866(&mut self, power: AuraDevRog1, on: bool) {
+        if let Self::AuraDevRog1(p) = self {
             if on {
                 p.insert(power);
             } else {
@@ -80,8 +78,8 @@ impl AuraPowerConfig {
         }
     }
 
-    pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) {
-        if let Self::AuraDev19b6(p) = self {
+    pub fn set_0x19b6(&mut self, power: AuraDevRog2, on: bool) {
+        if let Self::AuraDevRog2(p) = self {
             if on {
                 p.insert(power);
             } else {
@@ -99,12 +97,12 @@ impl From<&AuraPowerConfig> for AuraPowerDev {
                 x1866: vec![],
                 x19b6: vec![],
             },
-            AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
+            AuraPowerConfig::AuraDevRog1(d) => AuraPowerDev {
                 tuf: vec![],
                 x1866: d.iter().copied().collect(),
                 x19b6: vec![],
             },
-            AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
+            AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev {
                 tuf: vec![],
                 x1866: vec![],
                 x19b6: d.iter().copied().collect(),
@@ -113,7 +111,7 @@ impl From<&AuraPowerConfig> for AuraPowerDev {
     }
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 // #[serde(default)]
 pub struct AuraConfig {
     pub brightness: LedBrightness,
@@ -124,38 +122,44 @@ pub struct AuraConfig {
     pub enabled: AuraPowerConfig,
 }
 
-impl Default for AuraConfig {
-    fn default() -> Self {
-        let mut prod_id = AuraDevice::Unknown;
-        for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if HidRaw::new(prod).is_ok() {
-                prod_id = AuraDevice::from(*prod);
-                break;
-            }
-        }
+impl StdConfig for AuraConfig {
+    fn new() -> Self {
+        // Self::create_default(AuraDevice::X19b6, &LaptopLedData::get_data())
+        panic!("AuraConfig::new() should not be used, use AuraConfig::create_default() instead");
+    }
 
-        if prod_id == AuraDevice::Unknown {
-            if let Ok(p) = KeyboardLed::new() {
-                if p.has_kbd_rgb_mode() {
-                    prod_id = AuraDevice::Tuf;
-                }
-            }
-        }
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
 
-        let enabled = if prod_id == AuraDevice::X19B6 {
-            AuraPowerConfig::AuraDev19b6(HashSet::from([
-                AuraDev19b6::BootLogo,
-                AuraDev19b6::BootKeyb,
-                AuraDev19b6::SleepLogo,
-                AuraDev19b6::SleepKeyb,
-                AuraDev19b6::AwakeLogo,
-                AuraDev19b6::AwakeKeyb,
-                AuraDev19b6::ShutdownLogo,
-                AuraDev19b6::ShutdownKeyb,
-                AuraDev19b6::BootBar,
-                AuraDev19b6::AwakeBar,
-                AuraDev19b6::SleepBar,
-                AuraDev19b6::ShutdownBar,
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for AuraConfig {}
+
+impl AuraConfig {
+    pub fn create_default(prod_id: AuraDevice, support_data: &LaptopLedData) -> Self {
+        // create a default config here
+        let enabled = if prod_id == AuraDevice::X19b6 {
+            AuraPowerConfig::AuraDevRog2(HashSet::from([
+                AuraDevRog2::BootLogo,
+                AuraDevRog2::BootKeyb,
+                AuraDevRog2::SleepLogo,
+                AuraDevRog2::SleepKeyb,
+                AuraDevRog2::AwakeLogo,
+                AuraDevRog2::AwakeKeyb,
+                AuraDevRog2::ShutdownLogo,
+                AuraDevRog2::ShutdownKeyb,
+                AuraDevRog2::BootBar,
+                AuraDevRog2::AwakeBar,
+                AuraDevRog2::SleepBar,
+                AuraDevRog2::ShutdownBar,
+                AuraDevRog2::BootRearGlow,
+                AuraDevRog2::AwakeRearGlow,
+                AuraDevRog2::SleepRearGlow,
+                AuraDevRog2::ShutdownRearGlow,
             ]))
         } else if prod_id == AuraDevice::Tuf {
             AuraPowerConfig::AuraDevTuf(HashSet::from([
@@ -165,76 +169,31 @@ impl Default for AuraConfig {
                 AuraDevTuf::Keyboard,
             ]))
         } else {
-            AuraPowerConfig::AuraDev1866(HashSet::from([
-                AuraDev1866::Awake,
-                AuraDev1866::Boot,
-                AuraDev1866::Sleep,
-                AuraDev1866::Keyboard,
-                AuraDev1866::Lightbar,
+            AuraPowerConfig::AuraDevRog1(HashSet::from([
+                AuraDevRog1::Awake,
+                AuraDevRog1::Boot,
+                AuraDevRog1::Sleep,
+                AuraDevRog1::Keyboard,
+                AuraDevRog1::Lightbar,
             ]))
         };
-
-        AuraConfig {
+        let mut config = AuraConfig {
             brightness: LedBrightness::Med,
             current_mode: AuraModeNum::Static,
             builtins: BTreeMap::new(),
             multizone: None,
             multizone_on: false,
             enabled,
-        }
-    }
-}
+        };
 
-impl AuraConfig {
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load(supported_led_modes: &LaptopLedData) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&AURA_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    AURA_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                return AuraConfig::create_default(&mut file, supported_led_modes);
-            } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
-                    return data;
-                }
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    AURA_CONFIG_PATH, AURA_CONFIG_PATH
-                );
-                let cfg_old = AURA_CONFIG_PATH.to_string() + "-old";
-                std::fs::rename(AURA_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        AURA_CONFIG_PATH, err
-                    )
-                });
-            }
-        }
-        AuraConfig::create_default(&mut file, supported_led_modes)
-    }
-
-    fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
-        // create a default config here
-        let mut config = AuraConfig::default();
-
-        for n in &support_data.standard {
+        for n in &support_data.basic_modes {
             config
                 .builtins
                 .insert(*n, AuraEffect::default_with_mode(*n));
 
-            if !support_data.multizone.is_empty() {
+            if !support_data.basic_zones.is_empty() {
                 let mut default = vec![];
-                for (i, tmp) in support_data.multizone.iter().enumerate() {
+                for (i, tmp) in support_data.basic_zones.iter().enumerate() {
                     default.push(AuraEffect {
                         mode: *n,
                         zone: *tmp,
@@ -242,7 +201,7 @@ impl AuraConfig {
                         colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
                         speed: Speed::Med,
                         direction: Direction::Left,
-                    })
+                    });
                 }
                 if let Some(m) = config.multizone.as_mut() {
                     m.insert(*n, default);
@@ -253,68 +212,37 @@ impl AuraConfig {
                 }
             }
         }
-
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", AURA_CONFIG_PATH));
         config
     }
 
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&AURA_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", AURA_CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", AURA_CONFIG_PATH);
-            } else {
-                let x = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(AURA_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-
     /// Set the mode data, current mode, and if multizone enabled.
     ///
-    /// Multipurpose, will accept AuraEffect with zones and put in the correct store.
+    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct
+    /// store.
     pub fn set_builtin(&mut self, effect: AuraEffect) {
         self.current_mode = effect.mode;
-        match effect.zone() {
-            AuraZone::None => {
-                self.builtins.insert(*effect.mode(), effect);
-                self.multizone_on = false;
-            }
-            _ => {
-                if let Some(multi) = self.multizone.as_mut() {
-                    if let Some(fx) = multi.get_mut(effect.mode()) {
-                        for fx in fx.iter_mut() {
-                            if fx.zone == effect.zone {
-                                *fx = effect;
-                                return;
-                            }
+        if effect.zone() == AuraZone::None {
+            self.builtins.insert(*effect.mode(), effect);
+            self.multizone_on = false;
+        } else {
+            if let Some(multi) = self.multizone.as_mut() {
+                if let Some(fx) = multi.get_mut(effect.mode()) {
+                    for fx in fx.iter_mut() {
+                        if fx.zone == effect.zone {
+                            *fx = effect;
+                            return;
                         }
-                        fx.push(effect);
-                    } else {
-                        multi.insert(*effect.mode(), vec![effect]);
                     }
+                    fx.push(effect);
                 } else {
-                    let mut tmp = BTreeMap::new();
-                    tmp.insert(*effect.mode(), vec![effect]);
-                    self.multizone = Some(tmp);
+                    multi.insert(*effect.mode(), vec![effect]);
                 }
-                self.multizone_on = true;
+            } else {
+                let mut tmp = BTreeMap::new();
+                tmp.insert(*effect.mode(), vec![effect]);
+                self.multizone = Some(tmp);
             }
+            self.multizone_on = true;
         }
     }
 
@@ -328,12 +256,15 @@ impl AuraConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::AuraConfig;
+    use rog_aura::aura_detection::LaptopLedData;
+    use rog_aura::usb::AuraDevice;
     use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
 
+    use super::AuraConfig;
+
     #[test]
     fn set_multizone_4key_config() {
-        let mut config = AuraConfig::default();
+        let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
 
         let effect = AuraEffect {
             colour1: Colour(0xff, 0x00, 0xff),
@@ -379,7 +310,7 @@ mod tests {
 
     #[test]
     fn set_multizone_multimode_config() {
-        let mut config = AuraConfig::default();
+        let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
 
         let effect = AuraEffect {
             zone: AuraZone::Key1,

asusd/src/ctrl_aura/controller.rs

@@ -1,19 +1,18 @@
-use crate::{
-    error::RogError,
-    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-};
-use log::{info, warn};
-use rog_aura::{
-    usb::{AuraDevice, LED_APPLY, LED_SET},
-    AuraEffect, KeyColourArray, LedBrightness, PerKeyRaw, LED_MSG_LEN,
-};
-use rog_aura::{AuraZone, Direction, Speed, GRADIENT};
-use rog_platform::{hid_raw::HidRaw, keyboard_led::KeyboardLed, supported::LedSupportedFunctions};
 use std::collections::BTreeMap;
 
-use crate::GetSupported;
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{info, warn};
+use rog_aura::advanced::{LedUsbPackets, UsbPackets};
+use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
+use rog_aura::usb::{AuraDevice, LED_APPLY, LED_SET};
+use rog_aura::{AuraEffect, AuraZone, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardLed;
+use rog_platform::supported::LedSupportedFunctions;
 
 use super::config::{AuraConfig, AuraPowerConfig};
+use crate::error::RogError;
+use crate::GetSupported;
 
 impl GetSupported for CtrlKbdLed {
     type A = LedSupportedFunctions;
@@ -21,14 +20,14 @@ impl GetSupported for CtrlKbdLed {
     fn get_supported() -> Self::A {
         // let mode = <&str>::from(&<AuraModes>::from(*mode));
         let laptop = LaptopLedData::get_data();
-        let stock_led_modes = laptop.standard;
-        let multizone_led_mode = laptop.multizone;
-        let per_key_led_mode = laptop.per_key;
+        let stock_led_modes = laptop.basic_modes;
+        let multizone_led_mode = laptop.basic_zones;
+        let advanced_type = laptop.advanced_type;
 
         let mut prod_id = AuraDevice::Unknown;
-        for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if HidRaw::new(prod).is_ok() {
-                prod_id = AuraDevice::from(*prod);
+        for prod in ASUS_KEYBOARD_DEVICES {
+            if HidRaw::new(prod.into()).is_ok() {
+                prod_id = prod;
                 break;
             }
         }
@@ -41,11 +40,11 @@ impl GetSupported for CtrlKbdLed {
         }
 
         LedSupportedFunctions {
-            prod_id,
-            brightness_set: rgb.is_ok(),
-            stock_led_modes,
-            multizone_led_mode,
-            per_key_led_mode,
+            dev_id: prod_id,
+            brightness: rgb.is_ok(),
+            basic_modes: stock_led_modes,
+            basic_zones: multizone_led_mode,
+            advanced_type: advanced_type.into(),
         }
     }
 }
@@ -59,7 +58,7 @@ pub enum LEDNode {
 
 pub struct CtrlKbdLed {
     // TODO: config stores the keyboard type as an AuraPower, use or update this
-    pub led_prod: Option<String>,
+    pub led_prod: AuraDevice,
     pub led_node: LEDNode,
     pub kd_brightness: KeyboardLed,
     pub supported_modes: LaptopLedData,
@@ -69,34 +68,43 @@ pub struct CtrlKbdLed {
 }
 
 impl CtrlKbdLed {
-    pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
-        let mut led_prod = None;
-        let mut led_node = None;
-        for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            match HidRaw::new(prod) {
+    pub fn new(supported_modes: LaptopLedData) -> Result<Self, RogError> {
+        let mut led_prod = AuraDevice::Unknown;
+        let mut usb_node = None;
+        for prod in ASUS_KEYBOARD_DEVICES {
+            match HidRaw::new(prod.into()) {
                 Ok(node) => {
-                    led_prod = Some(prod.to_string());
-                    led_node = Some(node);
-                    info!("Looked for keyboard controller 0x{prod}: Found");
+                    led_prod = prod;
+                    usb_node = Some(node);
+                    info!(
+                        "Looked for keyboard controller 0x{}: Found",
+                        <&str>::from(prod)
+                    );
                     break;
                 }
-                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
+                Err(err) => info!(
+                    "Looked for keyboard controller 0x{}: {err}",
+                    <&str>::from(prod)
+                ),
             }
         }
 
         let rgb_led = KeyboardLed::new()?;
 
-        if led_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
+        if usb_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
             let dmi = sysfs_class::DmiId::default();
             if let Ok(prod_family) = dmi.product_family() {
                 if prod_family.contains("TUF") {
-                    warn!("A kernel patch is in progress for TUF RGB support");
+                    warn!(
+                        "kbd_rgb_mode was not found in the /sys/. You require a minimum 6.1 \
+                         kernel and a supported TUF laptop"
+                    );
                 }
             }
             return Err(RogError::NoAuraKeyboard);
         }
 
-        let led_node = if let Some(rog) = led_node {
+        let led_node = if let Some(rog) = usb_node {
             info!("Found ROG USB keyboard");
             LEDNode::Rog(rog)
         } else if rgb_led.has_kbd_rgb_mode() {
@@ -106,14 +114,44 @@ impl CtrlKbdLed {
             LEDNode::None
         };
 
+        let mut config_init = AuraConfig::create_default(led_prod, &supported_modes);
+        let mut config_loaded = config_init.clone().load();
+
+        for mode in &mut config_init.builtins {
+            // update init values from loaded values if they exist
+            if let Some(loaded) = config_loaded.builtins.get(mode.0) {
+                *mode.1 = loaded.clone();
+            }
+        }
+        config_loaded.builtins = config_init.builtins;
+
+        if let (Some(mut multizone_init), Some(multizone_loaded)) =
+            (config_init.multizone, config_loaded.multizone.as_mut())
+        {
+            for mode in multizone_init.iter_mut() {
+                // update init values from loaded values if they exist
+                if let Some(loaded) = multizone_loaded.get(mode.0) {
+                    let mut new_set = Vec::new();
+                    // only reuse a zone mode if the mode is supported
+                    for mode in loaded {
+                        if supported_modes.basic_modes.contains(&mode.mode) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
         let ctrl = CtrlKbdLed {
             led_prod,
-            led_node,
+            led_node,               // on TUF this is the same as rgb_led / kd_brightness
             kd_brightness: rgb_led, // If was none then we already returned above
             supported_modes,
             flip_effect_write: false,
             per_key_mode_active: false,
-            config,
+            config: config_loaded,
         };
         Ok(ctrl)
     }
@@ -152,7 +190,8 @@ impl CtrlKbdLed {
         self.set_brightness(self.config.brightness)
     }
 
-    /// Set combination state for boot animation/sleep animation/all leds/keys leds/side leds LED active
+    /// Set combination state for boot animation/sleep animation/all leds/keys
+    /// leds/side leds LED active
     pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
         if let LEDNode::KbdLed(platform) = &mut self.led_node {
             if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
@@ -161,7 +200,7 @@ impl CtrlKbdLed {
             }
         } else if let LEDNode::Rog(hid_raw) = &self.led_node {
             let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
-            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2]];
+            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3]];
 
             hid_raw.write_bytes(&message)?;
             hid_raw.write_bytes(&LED_SET)?;
@@ -173,12 +212,12 @@ impl CtrlKbdLed {
 
     /// Set an Aura effect if the effect mode or zone is supported.
     ///
-    /// On success the aura config file is read to refresh cached values, then the effect is
-    /// stored and config written to disk.
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
     pub(crate) fn set_effect(&mut self, effect: AuraEffect) -> Result<(), RogError> {
-        if !self.supported_modes.standard.contains(&effect.mode)
+        if !self.supported_modes.basic_modes.contains(&effect.mode)
             || effect.zone != AuraZone::None
-                && !self.supported_modes.multizone.contains(&effect.zone)
+                && !self.supported_modes.basic_zones.contains(&effect.zone)
         {
             return Err(RogError::AuraEffectNotSupported);
         }
@@ -186,14 +225,23 @@ impl CtrlKbdLed {
         self.write_mode(&effect)?;
         self.config.read(); // refresh config if successful
         self.config.set_builtin(effect);
+        if self.config.brightness == LedBrightness::Off {
+            self.config.brightness = LedBrightness::Med;
+        }
         self.config.write();
+        self.set_brightness(self.config.brightness)?;
         Ok(())
     }
 
     /// Write an effect block. This is for per-key, but can be repurposed to
     /// write the raw factory mode packets - when doing this it is expected that
     /// only the first `Vec` (`effect[0]`) is valid.
-    pub fn write_effect_block(&mut self, effect: &PerKeyRaw) -> Result<(), RogError> {
+    pub fn write_effect_block(&mut self, effect: &UsbPackets) -> Result<(), RogError> {
+        if self.config.brightness == LedBrightness::Off {
+            self.config.brightness = LedBrightness::Med;
+            self.config.write();
+        }
+
         let pkt_type = effect[0][1];
         const PER_KEY_TYPE: u8 = 0xbc;
 
@@ -207,7 +255,7 @@ impl CtrlKbdLed {
         } else {
             if !self.per_key_mode_active {
                 if let LEDNode::Rog(hid_raw) = &self.led_node {
-                    let init = KeyColourArray::get_init_msg();
+                    let init = LedUsbPackets::get_init_msg();
                     hid_raw.write_bytes(&init)?;
                 }
                 self.per_key_mode_active = true;
@@ -233,7 +281,7 @@ impl CtrlKbdLed {
         let current = self.config.current_mode;
         if let Some(idx) = self
             .supported_modes
-            .standard
+            .basic_modes
             .iter()
             .position(|v| *v == current)
         {
@@ -241,17 +289,17 @@ impl CtrlKbdLed {
             // goes past end of array
             if reverse {
                 if idx == 0 {
-                    idx = self.supported_modes.standard.len() - 1;
+                    idx = self.supported_modes.basic_modes.len() - 1;
                 } else {
                     idx -= 1;
                 }
             } else {
                 idx += 1;
-                if idx == self.supported_modes.standard.len() {
+                if idx == self.supported_modes.basic_modes.len() {
                     idx = 0;
                 }
             }
-            let next = self.supported_modes.standard[idx];
+            let next = self.supported_modes.basic_modes[idx];
 
             self.config.read();
             // if self.config.builtins.contains_key(&next) {
@@ -324,10 +372,11 @@ impl CtrlKbdLed {
         Ok(())
     }
 
-    /// Create a default for the `current_mode` if multizone and no config exists.
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
     fn create_multizone_default(&mut self) -> Result<(), RogError> {
         let mut default = vec![];
-        for (i, tmp) in self.supported_modes.multizone.iter().enumerate() {
+        for (i, tmp) in self.supported_modes.basic_zones.iter().enumerate() {
             default.push(AuraEffect {
                 mode: self.config.current_mode,
                 zone: *tmp,
@@ -335,7 +384,7 @@ impl CtrlKbdLed {
                 colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
                 speed: Speed::Med,
                 direction: Direction::Left,
-            })
+            });
         }
         if default.is_empty() {
             return Err(RogError::AuraEffectNotSupported);
@@ -354,30 +403,29 @@ impl CtrlKbdLed {
 
 #[cfg(test)]
 mod tests {
+    use rog_aura::aura_detection::LaptopLedData;
+    use rog_aura::usb::AuraDevice;
     use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
     use rog_platform::keyboard_led::KeyboardLed;
 
-    use crate::{
-        ctrl_aura::{config::AuraConfig, controller::LEDNode},
-        laptops::LaptopLedData,
-    };
-
     use super::CtrlKbdLed;
+    use crate::ctrl_aura::config::AuraConfig;
+    use crate::ctrl_aura::controller::LEDNode;
 
     #[test]
     // #[ignore = "Must be manually run due to detection stage"]
     fn check_set_mode_errors() {
         // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::default();
+        let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
         let supported_modes = LaptopLedData {
-            prod_family: "".into(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![],
-            per_key: false,
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::AdvancedAuraType::None,
         };
         let mut controller = CtrlKbdLed {
-            led_prod: None,
+            led_prod: AuraDevice::X19b6,
             led_node: LEDNode::None,
             kd_brightness: KeyboardLed::default(),
             supported_modes,
@@ -392,7 +440,8 @@ mod tests {
             ..Default::default()
         };
 
-        // This error comes from write_bytes because we don't have a keyboard node stored
+        // This error comes from write_bytes because we don't have a keyboard node
+        // stored
         assert_eq!(
             controller
                 .set_effect(effect.clone())
@@ -420,7 +469,7 @@ mod tests {
             "Aura effect not supported"
         );
 
-        controller.supported_modes.multizone.push(AuraZone::Key2);
+        controller.supported_modes.basic_zones.push(AuraZone::Key2);
         assert_eq!(
             controller.set_effect(effect).unwrap_err().to_string(),
             "No supported Aura keyboard"
@@ -430,16 +479,16 @@ mod tests {
     #[test]
     fn create_multizone_if_no_config() {
         // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::default();
+        let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
         let supported_modes = LaptopLedData {
-            prod_family: "".into(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![],
-            per_key: false,
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::AdvancedAuraType::None,
         };
         let mut controller = CtrlKbdLed {
-            led_prod: None,
+            led_prod: AuraDevice::X19b6,
             led_node: LEDNode::None,
             kd_brightness: KeyboardLed::default(),
             supported_modes,
@@ -452,8 +501,8 @@ mod tests {
         assert!(controller.create_multizone_default().is_err());
         assert!(controller.config.multizone.is_none());
 
-        controller.supported_modes.multizone.push(AuraZone::Key1);
-        controller.supported_modes.multizone.push(AuraZone::Key2);
+        controller.supported_modes.basic_zones.push(AuraZone::Key1);
+        controller.supported_modes.basic_zones.push(AuraZone::Key2);
         assert!(controller.create_multizone_default().is_ok());
         assert!(controller.config.multizone.is_some());
 
@@ -468,16 +517,16 @@ mod tests {
     #[test]
     fn next_mode_create_multizone_if_no_config() {
         // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::default();
+        let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
         let supported_modes = LaptopLedData {
-            prod_family: "".into(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![AuraZone::Key1, AuraZone::Key2],
-            per_key: false,
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![AuraZone::Key1, AuraZone::Key2],
+            advanced_type: rog_aura::AdvancedAuraType::None,
         };
         let mut controller = CtrlKbdLed {
-            led_prod: None,
+            led_prod: AuraDevice::X19b6,
             led_node: LEDNode::None,
             kd_brightness: KeyboardLed::default(),
             supported_modes,

asusd/src/ctrl_aura/mod.rs

@@ -1,4 +1,4 @@
 pub mod config;
 pub mod controller;
-/// Implements CtrlTask, Reloadable, ZbusRun
+/// Implements `CtrlTask`, `Reloadable`, `ZbusRun`
 pub mod trait_impls;

asusd/src/ctrl_aura/trait_impls.rs

@@ -1,19 +1,19 @@
-use async_trait::async_trait;
-use log::{error, info, warn};
-use rog_aura::{usb::AuraPowerDev, AuraEffect, AuraModeNum, LedBrightness, PerKeyRaw};
-use std::{collections::BTreeMap, sync::Arc};
-use zbus::{
-    dbus_interface,
-    export::futures_util::{
-        lock::{Mutex, MutexGuard},
-        StreamExt,
-    },
-    Connection, SignalContext,
-};
+use std::collections::BTreeMap;
+use std::sync::Arc;
 
-use crate::{error::RogError, CtrlTask};
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{error, info, warn};
+use rog_aura::advanced::UsbPackets;
+use rog_aura::usb::AuraPowerDev;
+use rog_aura::{AuraEffect, AuraModeNum, LedBrightness};
+use zbus::export::futures_util::lock::{Mutex, MutexGuard};
+use zbus::export::futures_util::StreamExt;
+use zbus::{dbus_interface, Connection, SignalContext};
 
 use super::controller::CtrlKbdLed;
+use crate::error::RogError;
+use crate::CtrlTask;
 
 pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Aura";
 
@@ -78,6 +78,10 @@ impl CtrlKbdLedZbus {
     ///     BootBar,
     ///     SleepBar,
     ///     ShutdownBar,
+    ///     BootRearBar,
+    ///     AwakeRearBar,
+    ///     SleepRearBar,
+    ///     ShutdownRearBar,
     /// }
     /// ```
     async fn set_leds_power(
@@ -122,6 +126,11 @@ impl CtrlKbdLedZbus {
             e
         })?;
 
+        ctrl.set_brightness(ctrl.config.brightness).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
         if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
             Self::notify_led(&ctxt, mode.clone())
                 .await
@@ -207,7 +216,10 @@ impl CtrlKbdLedZbus {
         ctrl.config.builtins.clone()
     }
 
-    async fn per_key_raw(&self, data: PerKeyRaw) -> zbus::fdo::Result<()> {
+    /// On machine that have some form of either per-key keyboard or per-zone
+    /// this can be used to write custom effects over dbus. The input is a
+    /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
+    async fn direct_addressing_raw(&self, data: UsbPackets) -> zbus::fdo::Result<()> {
         let mut ctrl = self.0.lock().await;
         ctrl.write_effect_block(&data)?;
         Ok(())
@@ -237,7 +249,7 @@ impl CtrlTask for CtrlKbdLedZbus {
     }
 
     async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
-        let load_save = |start: bool, mut lock: MutexGuard<CtrlKbdLed>| {
+        let load_save = |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| {
             // If waking up
             if !start {
                 info!("CtrlKbdLedTask reloading brightness and modes");
@@ -262,28 +274,32 @@ impl CtrlTask for CtrlKbdLedZbus {
         self.create_sys_event_tasks(
             // Loop so that we do aquire the lock but also don't block other
             // threads (prevents potential deadlocks)
-            move || loop {
-                if let Some(lock) = inner1.try_lock() {
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
                     load_save(true, lock);
-                    break;
                 }
             },
-            move || loop {
-                if let Some(lock) = inner2.try_lock() {
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
                     load_save(false, lock);
-                    break;
                 }
             },
-            move || loop {
-                if let Some(lock) = inner3.try_lock() {
-                    load_save(true, lock);
-                    break;
-                }
-            },
-            move || loop {
-                if let Some(lock) = inner4.try_lock() {
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
                     load_save(false, lock);
-                    break;
                 }
             },
         )
@@ -291,11 +307,11 @@ impl CtrlTask for CtrlKbdLedZbus {
 
         let ctrl2 = self.0.clone();
         let ctrl = self.0.lock().await;
-        let mut watch = ctrl.kd_brightness.monitor_brightness()?;
+        let watch = ctrl.kd_brightness.monitor_brightness()?;
         tokio::spawn(async move {
             let mut buffer = [0; 32];
             watch
-                .event_stream(&mut buffer)
+                .into_event_stream(&mut buffer)
                 .unwrap()
                 .for_each(|_| async {
                     if let Some(lock) = ctrl2.try_lock() {

asusd/src/ctrl_platform.rs

@@ -1,17 +1,20 @@
-use crate::{config::Config, error::RogError, GetSupported};
-use crate::{task_watch_item, CtrlTask};
-use async_trait::async_trait;
-use log::{info, warn};
-use rog_platform::platform::{AsusPlatform, GpuMode};
-use rog_platform::supported::RogBiosSupportedFunctions;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
 use std::path::Path;
 use std::process::Command;
 use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{info, warn};
+use rog_platform::platform::{AsusPlatform, GpuMode};
+use rog_platform::supported::RogBiosSupportedFunctions;
 use zbus::export::futures_util::lock::Mutex;
-use zbus::Connection;
-use zbus::{dbus_interface, SignalContext};
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{task_watch_item, CtrlTask, GetSupported};
 
 const ZBUS_PATH: &str = "/org/asuslinux/Platform";
 const ASUS_POST_LOGO_SOUND: &str =
@@ -28,12 +31,14 @@ impl GetSupported for CtrlPlatform {
 
     fn get_supported() -> Self::A {
         let mut panel_overdrive = false;
+        let mut mini_led_mode = false;
         let mut dgpu_disable = false;
         let mut egpu_enable = false;
         let mut gpu_mux = false;
 
         if let Ok(platform) = AsusPlatform::new() {
             panel_overdrive = platform.has_panel_od();
+            mini_led_mode = platform.has_mini_led_mode();
             dgpu_disable = platform.has_dgpu_disable();
             egpu_enable = platform.has_egpu_enable();
             gpu_mux = platform.has_gpu_mux_mode();
@@ -43,6 +48,7 @@ impl GetSupported for CtrlPlatform {
             post_sound: Path::new(ASUS_POST_LOGO_SOUND).exists(),
             gpu_mux,
             panel_overdrive,
+            mini_led_mode,
             dgpu_disable,
             egpu_enable,
         }
@@ -89,15 +95,8 @@ impl CtrlPlatform {
     }
 
     pub fn get_boot_sound() -> Result<i8, RogError> {
-        let path = ASUS_POST_LOGO_SOUND;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
+        let data = std::fs::read(ASUS_POST_LOGO_SOUND)
+            .map_err(|err| RogError::Read(ASUS_POST_LOGO_SOUND.into(), err))?;
 
         let idx = data.len() - 1;
         Ok(data[idx] as i8)
@@ -112,6 +111,7 @@ impl CtrlPlatform {
             .map_err(|err| RogError::Path(path.into(), err))?;
 
         let mut data = Vec::new();
+        #[allow(clippy::verbose_file_reads)]
         file.read_to_end(&mut data)
             .map_err(|err| RogError::Read(path.into(), err))?;
 
@@ -214,27 +214,54 @@ impl CtrlPlatform {
         };
     }
 
-    /// Get the `panel_od` value from platform. Updates the stored value in internal config also.
+    /// Get the `panel_od` value from platform. Updates the stored value in
+    /// internal config also.
     fn panel_od(&self) -> bool {
-        let od = self
-            .platform
+        self.platform
             .get_panel_od()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_panel_od {}", err);
                 err
             })
-            .unwrap_or(false);
-        if let Some(mut lock) = self.config.try_lock() {
-            lock.panel_od = od;
-            lock.write();
-        }
-        od
+            .unwrap_or(false)
     }
 
     #[dbus_interface(signal)]
     async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
     }
 
+    async fn set_mini_led_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        on: bool,
+    ) {
+        match self.platform.set_mini_led_mode(on) {
+            Ok(_) => {
+                if let Some(mut lock) = self.config.try_lock() {
+                    lock.mini_led_mode = on;
+                    lock.write();
+                }
+                Self::notify_mini_led_mode(&ctxt, on).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_mini_led_mode {}", err),
+        };
+    }
+
+    /// Get the `panel_od` value from platform. Updates the stored value in
+    /// internal config also.
+    fn mini_led_mode(&self) -> bool {
+        self.platform
+            .get_mini_led_mode()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_mini_led_mode {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_mini_led_mode(signal_ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
+
     async fn set_dgpu_disable(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
@@ -317,9 +344,12 @@ impl crate::Reloadable for CtrlPlatform {
 
 impl CtrlPlatform {
     task_watch_item!(panel_od platform);
+
     task_watch_item!(dgpu_disable platform);
+
     task_watch_item!(egpu_enable platform);
-    task_watch_item!(gpu_mux_mode platform);
+    // NOTE: see note further below
+    // task_watch_item!(gpu_mux_mode platform);
 }
 
 #[async_trait]
@@ -332,30 +362,34 @@ impl CtrlTask for CtrlPlatform {
         let platform1 = self.clone();
         let platform2 = self.clone();
         self.create_sys_event_tasks(
-            move || {},
+            move || async { {} },
             move || {
-                info!("CtrlRogBios reloading panel_od");
-                if let Some(lock) = platform1.config.try_lock() {
+                let platform1 = platform1.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform1.config.lock().await;
                     if platform1.platform.has_panel_od() {
                         platform1
                             .set_panel_overdrive(lock.panel_od)
                             .map_err(|err| {
-                                warn!("CtrlCharge: set_limit {}", err);
+                                warn!("CtrlCharge: panel_od {}", err);
                                 err
                             })
                             .ok();
                     }
                 }
             },
-            move || {},
+            move || async { {} },
             move || {
-                info!("CtrlRogBios reloading panel_od");
-                if let Some(lock) = platform2.config.try_lock() {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform2.config.lock().await;
                     if platform2.platform.has_panel_od() {
                         platform2
                             .set_panel_overdrive(lock.panel_od)
                             .map_err(|err| {
-                                warn!("CtrlCharge: set_limit {}", err);
+                                warn!("CtrlCharge: panel_od {}", err);
                                 err
                             })
                             .ok();
@@ -368,7 +402,9 @@ impl CtrlTask for CtrlPlatform {
         self.watch_panel_od(signal_ctxt.clone()).await?;
         self.watch_dgpu_disable(signal_ctxt.clone()).await?;
         self.watch_egpu_enable(signal_ctxt.clone()).await?;
-        self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+        // NOTE: Can't have this as a watch because on a write to it, it reverts back to
+        // booted-with value  as it does not actually change until reboot.
+        // self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
 
         Ok(())
     }

asusd/src/ctrl_power.rs

@@ -1,17 +1,20 @@
-use crate::systemd::{do_systemd_unit_action, SystemdUnitAction};
-use crate::{config::Config, error::RogError, GetSupported};
-use crate::{task_watch_item, CtrlTask};
-use async_trait::async_trait;
-use log::{info, warn};
-use rog_platform::power::AsusPower;
-use rog_platform::supported::ChargeSupportedFunctions;
+use std::process::Command;
 use std::sync::Arc;
 use std::time::Duration;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{error, info, warn};
+use rog_platform::power::AsusPower;
+use rog_platform::supported::ChargeSupportedFunctions;
+use systemd_zbus::{ManagerProxy as SystemdProxy, Mode, UnitFileState};
 use tokio::time::sleep;
-use zbus::dbus_interface;
 use zbus::export::futures_util::lock::Mutex;
-use zbus::Connection;
-use zbus::SignalContext;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{CtrlTask, GetSupported};
 
 const ZBUS_PATH: &str = "/org/asuslinux/Power";
 const NVIDIA_POWERD: &str = "nvidia-powerd.service";
@@ -117,6 +120,8 @@ impl crate::Reloadable for CtrlPower {
 }
 
 impl CtrlPower {
+    // task_watch_item!(charge_control_end_threshold power);
+
     pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
         Ok(CtrlPower {
             power: AsusPower::new()?,
@@ -141,8 +146,6 @@ impl CtrlPower {
 
         Ok(())
     }
-
-    task_watch_item!(charge_control_end_threshold power);
 }
 
 #[async_trait]
@@ -152,60 +155,64 @@ impl CtrlTask for CtrlPower {
     }
 
     async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let conn = zbus::Connection::system().await?;
+        let sysd1 = SystemdProxy::new(&conn).await?;
+        let sysd2 = sysd1.clone();
+        let sysd3 = sysd1.clone();
+
         let power1 = self.clone();
         let power2 = self.clone();
         self.create_sys_event_tasks(
-            move || {},
+            move || async {},
             move || {
-                info!("CtrlCharge reloading charge limit");
-                if let Some(lock) = power1.config.try_lock() {
-                    power1
+                let power = power1.clone();
+                let sysd = sysd1.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power.config.lock().await;
+                    power
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
                             warn!("CtrlCharge: set_limit {}", err);
                             err
                         })
                         .ok();
-                }
-                if let Ok(value) = power1.power.get_online() {
-                    let action = if value == 1 {
-                        SystemdUnitAction::Restart
-                    } else {
-                        SystemdUnitAction::Stop
-                    };
-                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
-                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+
+                    if lock.disable_nvidia_powerd_on_battery {
+                        if let Ok(value) = power.power.get_online() {
+                            do_nvidia_powerd_action(&sysd, value == 1).await;
+                        }
                     }
                 }
             },
-            move || {},
+            move || async {},
             move || {
-                info!("CtrlCharge reloading charge limit");
-                if let Some(lock) = power2.config.try_lock() {
-                    power2
+                let power = power2.clone();
+                let sysd = sysd2.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power.config.lock().await;
+                    power
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
                             warn!("CtrlCharge: set_limit {}", err);
                             err
                         })
                         .ok();
-                }
-                if let Ok(value) = power2.power.get_online() {
-                    let action = if value == 1 {
-                        SystemdUnitAction::Restart
-                    } else {
-                        SystemdUnitAction::Stop
-                    };
-                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
-                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+
+                    if lock.disable_nvidia_powerd_on_battery {
+                        if let Ok(value) = power.power.get_online() {
+                            do_nvidia_powerd_action(&sysd, value == 1).await;
+                        }
                     }
                 }
             },
         )
         .await;
 
-        self.watch_charge_control_end_threshold(signal_ctxt.clone())
-            .await?;
+        let config = self.config.clone();
+        // self.watch_charge_control_end_threshold(signal_ctxt.clone())
+        //     .await?;
 
         let ctrl = self.clone();
         tokio::spawn(async move {
@@ -214,18 +221,39 @@ impl CtrlTask for CtrlPower {
                 if let Ok(value) = ctrl.power.get_online() {
                     if online != value {
                         online = value;
-                        let action = if value == 1 {
-                            SystemdUnitAction::Restart
-                        } else {
-                            SystemdUnitAction::Stop
-                        };
-                        if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
-                            info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                        let mut config = config.lock().await;
+                        config.read();
+
+                        if config.disable_nvidia_powerd_on_battery {
+                            do_nvidia_powerd_action(&sysd3, value == 1).await;
                         }
 
                         Self::notify_mains_online(&signal_ctxt, value == 1)
                             .await
                             .unwrap();
+
+                        let mut prog: Vec<&str> = Vec::new();
+                        if value == 1 {
+                            // AC ONLINE
+                            prog = config.ac_command.split_whitespace().collect();
+                        } else if value == 0 {
+                            // BATTERY
+                            prog = config.bat_command.split_whitespace().collect();
+                        }
+
+                        if prog.len() > 1 {
+                            let mut cmd = Command::new(prog[0]);
+                            for arg in prog.iter().skip(1) {
+                                cmd.arg(*arg);
+                            }
+                            if let Err(e) = cmd.spawn() {
+                                if value == 1 {
+                                    error!("AC power command error: {e}");
+                                } else {
+                                    error!("Battery power command error: {e}");
+                                }
+                            }
+                        }
                     }
                 }
                 // The inotify doesn't pick up events when the kernel changes internal value
@@ -237,3 +265,23 @@ impl CtrlTask for CtrlPower {
         Ok(())
     }
 }
+
+async fn do_nvidia_powerd_action(proxy: &SystemdProxy<'_>, ac_on: bool) {
+    if let Ok(res) = proxy.get_unit_file_state(NVIDIA_POWERD).await {
+        if res == UnitFileState::Enabled {
+            if ac_on {
+                proxy
+                    .start_unit(NVIDIA_POWERD, Mode::Replace)
+                    .await
+                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
+                    .ok();
+            } else {
+                proxy
+                    .stop_unit(NVIDIA_POWERD, Mode::Replace)
+                    .await
+                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
+                    .ok();
+            }
+        }
+    }
+}

asusd/src/ctrl_profiles/config.rs

@@ -0,0 +1,60 @@
+use std::path::PathBuf;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_profiles::fan_curve_set::FanCurveSet;
+use rog_profiles::Profile;
+use serde_derive::{Deserialize, Serialize};
+
+use crate::CONFIG_PATH_BASE;
+
+const CONFIG_FILE: &str = "profile.ron";
+const CONFIG_FAN_FILE: &str = "fan_curves.ron";
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ProfileConfig {
+    /// For restore on boot
+    pub active_profile: Profile,
+}
+
+impl StdConfig for ProfileConfig {
+    fn new() -> Self {
+        Self {
+            active_profile: Profile::Balanced,
+        }
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for ProfileConfig {}
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub balanced: FanCurveSet,
+    pub performance: FanCurveSet,
+    pub quiet: FanCurveSet,
+}
+
+impl StdConfig for FanCurveConfig {
+    /// Create a new config. The defaults are zeroed so the device must be read
+    /// to get the actual device defaults.
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FAN_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for FanCurveConfig {}

asusd/src/ctrl_profiles/controller.rs

@@ -0,0 +1,175 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{info, warn};
+use rog_platform::platform::AsusPlatform;
+use rog_platform::supported::PlatformProfileFunctions;
+use rog_profiles::error::ProfileError;
+use rog_profiles::{FanCurveProfiles, Profile};
+
+use super::config::{FanCurveConfig, ProfileConfig};
+use crate::error::RogError;
+use crate::GetSupported;
+
+// TODO: macro wrapper for warn/info/error log macros to add module name
+const MOD_NAME: &str = "CtrlPlatformProfile";
+
+pub struct FanCurves {
+    config_file: FanCurveConfig,
+    profiles: FanCurveProfiles,
+}
+
+impl FanCurves {
+    pub fn update_profiles_from_config(&mut self) {
+        self.profiles.balanced = self.config_file.balanced.clone();
+        self.profiles.performance = self.config_file.performance.clone();
+        self.profiles.quiet = self.config_file.quiet.clone();
+    }
+
+    pub fn update_config_from_profiles(&mut self) {
+        self.config_file.balanced = self.profiles.balanced.clone();
+        self.config_file.performance = self.profiles.performance.clone();
+        self.config_file.quiet = self.profiles.quiet.clone();
+    }
+
+    pub fn profiles(&self) -> &FanCurveProfiles {
+        &self.profiles
+    }
+
+    pub fn profiles_mut(&mut self) -> &mut FanCurveProfiles {
+        &mut self.profiles
+    }
+}
+
+pub struct CtrlPlatformProfile {
+    pub profile_config: ProfileConfig,
+    pub fan_curves: Option<FanCurves>,
+    pub platform: AsusPlatform,
+}
+
+impl GetSupported for CtrlPlatformProfile {
+    type A = PlatformProfileFunctions;
+
+    fn get_supported() -> Self::A {
+        if !Profile::is_platform_profile_supported() {
+            warn!(
+                "platform_profile kernel interface not found, your laptop does not support this, \
+                 or the interface is missing."
+            );
+        }
+
+        let res = FanCurveProfiles::is_supported();
+        let mut fan_curve_supported = res.is_err();
+        if let Ok(r) = res {
+            fan_curve_supported = r;
+        };
+
+        if !fan_curve_supported {
+            info!(
+                "fan curves kernel interface not found, your laptop does not support this, or the \
+                 interface is missing."
+            );
+        }
+
+        PlatformProfileFunctions {
+            platform_profile: Profile::is_platform_profile_supported(),
+            fan_curves: fan_curve_supported,
+        }
+    }
+}
+
+impl CtrlPlatformProfile {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
+        let platform = AsusPlatform::new()?;
+        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
+            info!("{MOD_NAME}: Device has profile control available");
+
+            let mut controller = CtrlPlatformProfile {
+                profile_config: config,
+                fan_curves: None,
+                platform,
+            };
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("{MOD_NAME}: Device has fan curves available");
+                let fan_config = FanCurveConfig::new();
+                // Only do defaults if the config doesn't already exist
+                if !fan_config.file_path().exists() {
+                    info!("{MOD_NAME}: Fetching default fan curves");
+                    controller.fan_curves = Some(FanCurves {
+                        config_file: fan_config,
+                        profiles: FanCurveProfiles::default(),
+                    });
+                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
+                        // For each profile we need to switch to it before we
+                        // can read the existing values from hardware. The ACPI method used
+                        // for this is what limits us.
+                        let next =
+                            Profile::get_next_profile(controller.profile_config.active_profile);
+                        Profile::set_profile(next)
+                            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
+                            .ok();
+                        controller.profile_config.active_profile = next;
+
+                        // Make sure to set the baseline to default
+                        controller.set_active_curve_to_defaults()?;
+                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+                        if let Some(curves) = controller.fan_curves.as_ref() {
+                            info!(
+                                "{MOD_NAME}: {active:?}: {}",
+                                String::from(curves.profiles().get_fan_curves_for(active))
+                            );
+                        }
+                    }
+                    if let Some(curves) = controller.fan_curves.as_ref() {
+                        curves.config_file.write();
+                    }
+                } else {
+                    info!("{MOD_NAME}: Fan curves previously stored, loading...");
+                    let mut fan_curves = FanCurves {
+                        config_file: fan_config.load(),
+                        profiles: FanCurveProfiles::default(),
+                    };
+                    fan_curves.update_profiles_from_config();
+                    controller.fan_curves = Some(fan_curves);
+                }
+            }
+
+            return Ok(controller);
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+
+    pub fn save_config(&mut self) {
+        self.profile_config.write();
+        if let Some(fans) = self.fan_curves.as_mut() {
+            fans.update_config_from_profiles();
+            fans.config_file.write(); // config write
+        }
+    }
+
+    /// Set the curve for the active profile active
+    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = &mut self.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().write_profile_curve_to_platform(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = self.fan_curves.as_mut() {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().set_active_curve_to_defaults(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+                curves.update_config_from_profiles();
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_profiles/mod.rs

@@ -1,4 +1,4 @@
 pub mod config;
 pub mod controller;
-/// Implements CtrlTask, Reloadable, ZbusRun
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
 pub mod trait_impls;

asusd/src/ctrl_profiles/trait_impls.rs

@@ -0,0 +1,316 @@
+use std::str::FromStr;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{error, info, warn};
+use rog_profiles::fan_curve_set::{CurveData, FanCurveSet};
+use rog_profiles::{FanCurveProfiles, Profile};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::export::futures_util::StreamExt;
+use zbus::fdo::Error;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use super::controller::CtrlPlatformProfile;
+use crate::error::RogError;
+use crate::CtrlTask;
+
+const MOD_NAME: &str = "ProfileZbus";
+
+const ZBUS_PATH: &str = "/org/asuslinux/Profile";
+const UNSUPPORTED_MSG: &str =
+    "Fan curves are not supported on this laptop or you require a patched kernel";
+
+#[derive(Clone)]
+pub struct ProfileZbus(pub Arc<Mutex<CtrlPlatformProfile>>);
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl ProfileZbus {
+    /// Fetch profile names
+    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        if let Ok(profiles) = Profile::get_profile_names() {
+            return Ok(profiles);
+        }
+        Err(Error::Failed(
+            "Failed to get all profile details".to_owned(),
+        ))
+    }
+
+    /// Toggle to next platform_profile. Names provided by `Profiles`.
+    /// If fan-curves are supported will also activate a fan curve for profile.
+    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut ctrl = self.0.lock().await;
+        let next = Profile::get_next_profile(ctrl.profile_config.active_profile);
+        Profile::set_profile(next)
+            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
+            .ok();
+        ctrl.profile_config.active_profile = next;
+        ctrl.save_config();
+
+        Self::notify_profile(&ctxt, ctrl.profile_config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Fetch the active profile name
+    async fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        Ok(ctrl.profile_config.active_profile)
+    }
+
+    /// Set this platform_profile name as active
+    async fn set_active_profile(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        profile: Profile,
+    ) {
+        let mut ctrl = self.0.lock().await;
+        // Read first just incase the user has modified the config before calling this
+        ctrl.profile_config.read();
+        Profile::set_profile(profile)
+            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
+            .ok();
+        ctrl.profile_config.active_profile = profile;
+        ctrl.write_profile_curve_to_platform()
+            .map_err(|e| warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e))
+            .ok();
+
+        ctrl.save_config();
+
+        Self::notify_profile(&ctxt, ctrl.profile_config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Get a list of profiles that have fan-curves enabled.
+    async fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        if let Some(curves) = &mut ctrl.fan_curves {
+            return Ok(curves.profiles().get_enabled_curve_profiles());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
+    }
+
+    /// Set a profile fan curve enabled status. Will also activate a fan curve
+    /// if in the same profile mode
+    async fn set_fan_curve_enabled(
+        &mut self,
+        profile: Profile,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        if let Some(curves) = &mut ctrl.fan_curves {
+            curves
+                .profiles_mut()
+                .set_profile_curve_enabled(profile, enabled);
+
+            ctrl.write_profile_curve_to_platform()
+                .map_err(|e| warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e))
+                .ok();
+
+            ctrl.save_config();
+            Ok(())
+        } else {
+            Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
+        }
+    }
+
+    /// Get the fan-curve data for the currently active Profile
+    async fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        if let Some(curves) = &mut ctrl.fan_curves {
+            let curve = curves.profiles().get_fan_curves_for(profile);
+            return Ok(curve.clone());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    async fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        if let Some(curves) = &mut ctrl.fan_curves {
+            curves
+                .profiles_mut()
+                .save_fan_curve(curve, profile)
+                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+        } else {
+            return Err(Error::Failed(UNSUPPORTED_MSG.to_owned()));
+        }
+        ctrl.write_profile_curve_to_platform()
+            .map_err(|e| warn!("{MOD_NAME}: Profile::set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be
+    /// read only for the currently active profile.
+    async fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        ctrl.set_active_curve_to_defaults()
+            .map_err(|e| warn!("{MOD_NAME}: Profile::set_active_curve_to_defaults, {}", e))
+            .ok();
+        ctrl.save_config();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be
+    /// read only for the currently active profile.
+    async fn reset_profile_curves(&self, profile: Profile) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.profile_config.read();
+        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+        Profile::set_profile(profile)
+            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
+            .ok();
+        ctrl.set_active_curve_to_defaults()
+            .map_err(|e| warn!("{MOD_NAME}: Profile::set_active_curve_to_defaults, {}", e))
+            .ok();
+
+        Profile::set_profile(active)
+            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+        Ok(())
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for ProfileZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl CtrlTask for ProfileZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let ctrl = self.0.clone();
+        let sig_ctx = signal_ctxt.clone();
+        let watch = self
+            .0
+            .lock()
+            .await
+            .platform
+            .monitor_throttle_thermal_policy()?;
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
+                stream
+                    .for_each(|_| async {
+                        let mut lock = ctrl.lock().await;
+                        if let Ok(profile) =
+                            lock.platform.get_throttle_thermal_policy().map_err(|e| {
+                                error!("{MOD_NAME}: get_throttle_thermal_policy error: {e}");
+                            })
+                        {
+                            let new_profile = Profile::from_throttle_thermal_policy(profile);
+                            if new_profile != lock.profile_config.active_profile {
+                                info!("{MOD_NAME}: platform_profile changed to {new_profile}");
+                                lock.profile_config.active_profile = new_profile;
+                                lock.write_profile_curve_to_platform().unwrap();
+                                lock.save_config();
+                                Profile::set_profile(lock.profile_config.active_profile)
+                                    .map_err(|e| {
+                                        error!("Profile::set_profile() error: {e}");
+                                    })
+                                    .ok();
+
+                                Self::notify_profile(&sig_ctx, lock.profile_config.active_profile)
+                                    .await
+                                    .ok();
+                            }
+                        }
+                    })
+                    .await;
+            }
+        });
+
+        let ctrl = self.0.clone();
+        let watch = self.0.lock().await.platform.monitor_platform_profile()?;
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
+                stream
+                    .for_each(|_| async {
+                        let mut lock = ctrl.lock().await;
+                        if let Ok(profile) = lock.platform.get_platform_profile().map_err(|e| {
+                            error!("get_platform_profile error: {e}");
+                        }) {
+                            if let Ok(new_profile) = Profile::from_str(&profile).map_err(|e| {
+                                error!("Profile::from_str(&profile) error: {e}");
+                            }) {
+                                if new_profile != lock.profile_config.active_profile {
+                                    info!("{MOD_NAME}: platform_profile changed to {new_profile}");
+                                    lock.profile_config.active_profile = new_profile;
+                                    lock.write_profile_curve_to_platform().unwrap();
+                                    lock.save_config();
+                                    Profile::set_profile(lock.profile_config.active_profile)
+                                        .map_err(|e| {
+                                            error!("Profile::set_profile() error: {e}");
+                                        })
+                                        .ok();
+
+                                    Self::notify_profile(
+                                        &signal_ctxt,
+                                        lock.profile_config.active_profile,
+                                    )
+                                    .await
+                                    .ok();
+                                }
+                            }
+                        }
+                    })
+                    .await;
+            }
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for ProfileZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        let active = ctrl.profile_config.active_profile;
+        if let Some(curves) = &mut ctrl.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                // There is a possibility that the curve was default zeroed, so this call
+                // initialises the data from system read and we need to save it
+                // after
+                curves
+                    .profiles_mut()
+                    .write_profile_curve_to_platform(active, &mut device)?;
+                ctrl.profile_config.write();
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_supported.rs

@@ -1,29 +1,22 @@
 use async_trait::async_trait;
 use serde_derive::{Deserialize, Serialize};
-use zbus::dbus_interface;
-use zbus::Connection;
-use zvariant::Type;
+use zbus::zvariant::Type;
+use zbus::{dbus_interface, Connection};
 
-use crate::{
-    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_platform::CtrlPlatform,
-    ctrl_power::CtrlPower, ctrl_profiles::controller::CtrlPlatformProfile, GetSupported,
-};
+use crate::ctrl_anime::CtrlAnime;
+use crate::ctrl_aura::controller::CtrlKbdLed;
+use crate::ctrl_platform::CtrlPlatform;
+use crate::ctrl_power::CtrlPower;
+use crate::ctrl_profiles::controller::CtrlPlatformProfile;
+use crate::GetSupported;
 
-use rog_platform::supported::*;
-
-#[derive(Serialize, Deserialize, Type)]
-pub struct SupportedFunctions {
-    pub anime_ctrl: AnimeSupportedFunctions,
-    pub charge_ctrl: ChargeSupportedFunctions,
-    pub platform_profile: PlatformProfileFunctions,
-    pub keyboard_led: LedSupportedFunctions,
-    pub rog_bios_ctrl: RogBiosSupportedFunctions,
-}
+#[derive(Serialize, Deserialize, Debug, Type)]
+pub struct SupportedFunctions(rog_platform::supported::SupportedFunctions);
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl SupportedFunctions {
-    fn supported_functions(&self) -> &SupportedFunctions {
-        self
+    pub fn supported_functions(&self) -> &rog_platform::supported::SupportedFunctions {
+        &self.0
     }
 }
 
@@ -38,12 +31,12 @@ impl GetSupported for SupportedFunctions {
     type A = SupportedFunctions;
 
     fn get_supported() -> Self::A {
-        SupportedFunctions {
+        Self(rog_platform::supported::SupportedFunctions {
             anime_ctrl: CtrlAnime::get_supported(),
             keyboard_led: CtrlKbdLed::get_supported(),
             charge_ctrl: CtrlPower::get_supported(),
             platform_profile: CtrlPlatformProfile::get_supported(),
             rog_bios_ctrl: CtrlPlatform::get_supported(),
-        }
+        })
     }
 }

asusd/src/daemon.rs

@@ -6,36 +6,34 @@ use std::time::Duration;
 
 use ::zbus::export::futures_util::lock::Mutex;
 use ::zbus::Connection;
-use daemon::ctrl_anime::CtrlAnime;
-use log::LevelFilter;
+use asusd::config::Config;
+use asusd::ctrl_anime::config::AnimeConfig;
+use asusd::ctrl_anime::trait_impls::CtrlAnimeZbus;
+use asusd::ctrl_anime::CtrlAnime;
+use asusd::ctrl_aura::controller::CtrlKbdLed;
+use asusd::ctrl_aura::trait_impls::CtrlKbdLedZbus;
+use asusd::ctrl_platform::CtrlPlatform;
+use asusd::ctrl_power::CtrlPower;
+use asusd::ctrl_profiles::config::ProfileConfig;
+use asusd::ctrl_profiles::controller::CtrlPlatformProfile;
+use asusd::ctrl_profiles::trait_impls::ProfileZbus;
+use asusd::ctrl_supported::SupportedFunctions;
+use asusd::{print_board_info, CtrlTask, GetSupported, Reloadable, ZbusRun};
+use config_traits::{StdConfig, StdConfigLoad, StdConfigLoad2};
 use log::{error, info, warn};
-use tokio::time::sleep;
-use zbus::SignalContext;
-
-use daemon::ctrl_anime::{config::AnimeConfig, trait_impls::CtrlAnimeZbus};
-use daemon::ctrl_aura::{config::AuraConfig, controller::CtrlKbdLed, trait_impls::CtrlKbdLedZbus};
-use daemon::ctrl_platform::CtrlPlatform;
-use daemon::ctrl_power::CtrlPower;
-use daemon::ctrl_profiles::{
-    config::ProfileConfig, controller::CtrlPlatformProfile, trait_impls::ProfileZbus,
-};
-use daemon::laptops::LaptopLedData;
-use daemon::{
-    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
-};
-use daemon::{CtrlTask, Reloadable, ZbusRun};
+use rog_aura::aura_detection::LaptopLedData;
 use rog_dbus::DBUS_NAME;
 use rog_profiles::Profile;
-
-static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
+use tokio::time::sleep;
+use zbus::SignalContext;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
     logger
+        .parse_default_env()
         .target(env_logger::Target::Stdout)
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
         .init();
 
     let is_service = match env::var_os("IS_SERVICE") {
@@ -52,7 +50,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    info!("       daemon v{}", daemon::VERSION);
+    info!("       daemon v{}", asusd::VERSION);
     info!("    rog-anime v{}", rog_anime::VERSION);
     info!("     rog-aura v{}", rog_aura::VERSION);
     info!("     rog-dbus v{}", rog_dbus::VERSION);
@@ -67,12 +65,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 async fn start_daemon() -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
-    println!("{}", serde_json::to_string_pretty(&supported)?);
+    println!("{}", supported.supported_functions());
 
     // Start zbus server
     let mut connection = Connection::system().await?;
 
-    let config = Config::load();
+    let config = Config::new().load();
     let config = Arc::new(Mutex::new(config));
 
     supported.add_to_server(&mut connection).await;
@@ -98,7 +96,7 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     if Profile::is_platform_profile_supported() {
-        let profile_config = ProfileConfig::load(PROFILE_CONFIG_PATH.into());
+        let profile_config = ProfileConfig::new().load();
         match CtrlPlatformProfile::new(profile_config) {
             Ok(ctrl) => {
                 let zbus = ProfileZbus(Arc::new(Mutex::new(ctrl)));
@@ -113,7 +111,7 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
         warn!("platform_profile support not found");
     }
 
-    match CtrlAnime::new(AnimeConfig::load()) {
+    match CtrlAnime::new(AnimeConfig::new().load()) {
         Ok(ctrl) => {
             let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
             let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
@@ -125,8 +123,9 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     let laptop = LaptopLedData::get_data();
-    let aura_config = AuraConfig::load(&laptop);
-    match CtrlKbdLed::new(laptop, aura_config) {
+    // CtrlKbdLed deviates from the config pattern above due to requiring a keyboard
+    // detection first
+    match CtrlKbdLed::new(laptop) {
         Ok(ctrl) => {
             let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
             let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;

asusd/src/error.rs

@@ -1,8 +1,10 @@
+use std::convert::From;
+use std::fmt;
+
+use config_traits::ron;
 use rog_anime::error::AnimeError;
 use rog_platform::error::PlatformError;
 use rog_profiles::error::ProfileError;
-use std::convert::From;
-use std::fmt;
 
 #[derive(Debug)]
 pub enum RogError {
@@ -33,11 +35,12 @@ pub enum RogError {
     SystemdUnitAction(String),
     SystemdUnitWaitTimeout(String),
     Command(String, std::io::Error),
+    ParseRon(ron::Error),
 }
 
 impl fmt::Display for RogError {
     // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
             RogError::ParseLed => write!(f, "Parse LED error"),
@@ -50,14 +53,21 @@ impl fmt::Display for RogError {
             RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
             RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
             RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
-            RogError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
-            RogError::ReloadFail(deets) => write!(f, "Task error: {}", deets),
+            RogError::MissingLedBrightNode(path, error) => write!(
+                f,
+                "Led node at {} is missing, please check you have the required patch or dkms \
+                 module installed: {}",
+                path, error
+            ),
+            RogError::ReloadFail(deets) => write!(f, "Reload error: {}", deets),
             RogError::Profiles(deets) => write!(f, "Profile error: {}", deets),
             RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
             RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
-            RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
+            RogError::ChargeLimit(value) => {
+                write!(f, "Invalid charging limit, not in range 20-100%: {}", value)
+            }
             RogError::AuraEffectNotSupported => write!(f, "Aura effect not supported"),
             RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
@@ -74,6 +84,7 @@ impl fmt::Display for RogError {
                 )
             }
             RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
+            RogError::ParseRon(error) => write!(f, "Parse config error: {}", error),
         }
     }
 }
@@ -110,6 +121,12 @@ impl From<std::io::Error> for RogError {
     }
 }
 
+impl From<ron::Error> for RogError {
+    fn from(err: ron::Error) -> Self {
+        RogError::ParseRon(err)
+    }
+}
+
 impl From<RogError> for zbus::fdo::Error {
     #[inline]
     fn from(err: RogError) -> Self {

asusd/src/lib.rs

@@ -1,7 +1,7 @@
 #![deny(unused_must_use)]
 /// Configuration loading, saving
 pub mod config;
-/// Control of AniMe matrix display
+/// Control of anime matrix display
 pub mod ctrl_anime;
 /// Keyboard LED brightness control, RGB, and LED display modes
 pub mod ctrl_aura;
@@ -11,32 +11,37 @@ pub mod ctrl_platform;
 pub mod ctrl_power;
 /// Control platform profiles + fan-curves if available
 pub mod ctrl_profiles;
-/// Laptop matching to determine capabilities
-pub mod laptops;
-
-pub mod systemd;
 
 /// Fetch all supported functions for the laptop
 pub mod ctrl_supported;
 
 pub mod error;
 
-use crate::error::RogError;
-use async_trait::async_trait;
-use log::warn;
-use logind_zbus::manager::ManagerProxy;
-use zbus::{export::futures_util::StreamExt, Connection, SignalContext};
-use zvariant::ObjectPath;
+use std::future::Future;
 
-/// This macro adds a function which spawns an `inotify` task on the passed in `Executor`.
+use async_trait::async_trait;
+use log::{debug, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use zbus::export::futures_util::StreamExt;
+use zbus::zvariant::ObjectPath;
+use zbus::{Connection, SignalContext};
+
+use crate::error::RogError;
+
+const CONFIG_PATH_BASE: &str = "/etc/asusd/";
+
+/// This macro adds a function which spawns an `inotify` task on the passed in
+/// `Executor`.
 ///
-/// The generated function is `watch_<name>()`. Self requires the following methods to be available:
-/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have side effects.
+/// The generated function is `watch_<name>()`. Self requires the following
+/// methods to be available:
+/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have
+///   side effects.
 /// - `notify_<name>(SignalContext, SomeValue)`
 ///
-/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is expected to update it.
-/// The getter should *never* write back to the path or attribute that is being watched or an
-/// infinite loop will occur.
+/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is
+/// expected to update it. The getter should *never* write back to the path or
+/// attribute that is being watched or an infinite loop will occur.
 ///
 /// # Example
 ///
@@ -46,6 +51,7 @@ use zvariant::ObjectPath;
 ///     task_watch_item!(gpu_mux_mode platform);
 /// }
 /// ```
+/// // TODO: this is kind of useless if it can't trigger some action
 #[macro_export]
 macro_rules! task_watch_item {
     ($name:ident $self_inner:ident) => {
@@ -59,12 +65,11 @@ macro_rules! task_watch_item {
             let ctrl = self.clone();
             concat_idents::concat_idents!(watch_fn = monitor_, $name {
                 match self.$self_inner.watch_fn() {
-                    Ok(mut watch) => {
+                    Ok(watch) => {
                         tokio::spawn(async move {
                             let mut buffer = [0; 32];
-                            watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
                                 let value = ctrl.$name();
-                                dbg!(&value);
                                 concat_idents::concat_idents!(notif_fn = notify_, $name {
                                     Self::notif_fn(&signal_ctxt, value).await.ok();
                                 });
@@ -82,6 +87,15 @@ macro_rules! task_watch_item {
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
+pub fn print_board_info() {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name().expect("Could not get board_name");
+    let prod_family = dmi.product_family().expect("Could not get product_family");
+
+    info!("Product family: {}", prod_family.trim());
+    info!("Board name: {}", board_name.trim());
+}
+
 #[async_trait]
 pub trait Reloadable {
     async fn reload(&mut self) -> Result<(), RogError>;
@@ -117,13 +131,14 @@ pub trait CtrlTask {
         SignalContext::new(connection, Self::zbus_path())
     }
 
-    /// Implement to set up various tasks that may be required, using the `Executor`.
-    /// No blocking loops are allowed, or they must be run on a separate thread.
+    /// Implement to set up various tasks that may be required, using the
+    /// `Executor`. No blocking loops are allowed, or they must be run on a
+    /// separate thread.
     async fn create_tasks(&self, signal: SignalContext<'static>) -> Result<(), RogError>;
 
     // /// Create a timed repeating task
-    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send + 'static) {
-    //     use std::time::Duration;
+    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send +
+    // 'static) {     use std::time::Duration;
     //     use tokio::time;
     //     let mut timer = time::interval(Duration::from_millis(millis));
     //     tokio::spawn(async move {
@@ -132,17 +147,36 @@ pub trait CtrlTask {
     //     });
     // }
 
-    /// Free helper method to create tasks to run on: sleep, wake, shutdown, boot
+    /// Free helper method to create tasks to run on: sleep, wake, shutdown,
+    /// boot
     ///
-    /// The closures can potentially block, so execution time should be the minimal possible
-    /// such as save a variable.
-    async fn create_sys_event_tasks(
+    /// The closures can potentially block, so execution time should be the
+    /// minimal possible such as save a variable.
+    async fn create_sys_event_tasks<
+        Fut1,
+        Fut2,
+        Fut3,
+        Fut4,
+        F1: Send + 'static,
+        F2: Send + 'static,
+        F3: Send + 'static,
+        F4: Send + 'static,
+    >(
         &self,
-        mut on_sleep: impl FnMut() + Send + 'static,
-        mut on_wake: impl FnMut() + Send + 'static,
-        mut on_shutdown: impl FnMut() + Send + 'static,
-        mut on_boot: impl FnMut() + Send + 'static,
-    ) {
+        mut on_sleep: F1,
+        mut on_wake: F2,
+        mut on_shutdown: F3,
+        mut on_boot: F4,
+    ) where
+        F1: FnMut() -> Fut1,
+        F2: FnMut() -> Fut2,
+        F3: FnMut() -> Fut3,
+        F4: FnMut() -> Fut4,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
         let connection = Connection::system()
             .await
             .expect("Controller could not create dbus connection");
@@ -156,9 +190,11 @@ pub trait CtrlTask {
                 while let Some(event) = notif.next().await {
                     if let Ok(args) = event.args() {
                         if args.start {
-                            on_sleep();
+                            debug!("Doing on_sleep()");
+                            on_sleep().await;
                         } else if !args.start() {
-                            on_wake();
+                            debug!("Doing on_wake()");
+                            on_wake().await;
                         }
                     }
                 }
@@ -174,9 +210,11 @@ pub trait CtrlTask {
                 while let Some(event) = notif.next().await {
                     if let Ok(args) = event.args() {
                         if args.start {
-                            on_shutdown();
+                            debug!("Doing on_shutdown()");
+                            on_shutdown().await;
                         } else if !args.start() {
-                            on_boot();
+                            debug!("Doing on_boot()");
+                            on_boot().await;
                         }
                     }
                 }

config-traits/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "config-traits"
+license = "MPL-2.0"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+ron.workspace = true
+
+log.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

config-traits/README.md

@@ -0,0 +1,10 @@
+# config-traits
+
+`config_traits` is a crate that broke out from the requirement to manage various
+different config files, including parsing from different formats and updating
+them from previous versions where fields or names are changed in some way.
+
+The end canonical file format is `.ron` as this supports rust types well, and includes
+the ability to add commenting, and is less verbose than `json`. Currently the crate will
+also try to parse from `json` and `toml` if the `ron` parsing fails, then update to `ron`
+format.

config-traits/src/lib.rs

@@ -0,0 +1,328 @@
+//! `config_traits` is a crate that broke out from the requirement to manage
+//! various different config files, including parsing from different formats and
+//! updating them from previous versions where fields or names are changed in
+//! some way.
+//!
+//! The end canonical file format is `.ron` as this supports rust types well,
+//! and includes the ability to add commenting, and is less verbose than `json`.
+//! Currently the crate will also try to parse from `json` and `toml` if the
+//! `ron` parsing fails, then update to `ron` format.
+
+use std::fs::{self, create_dir, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use log::{error, warn};
+pub use ron;
+use ron::ser::PrettyConfig;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+/// Config file helper traits. Only `new()` and `file_name()` are required to be
+/// implemented, the rest are intended to be free methods.
+pub trait StdConfig
+where
+    Self: Serialize + DeserializeOwned,
+{
+    /// Taking over the standard `new()` to ensure things can be generic
+    fn new() -> Self;
+
+    /// Return the config files names, such as `wibble.cfg`
+    fn file_name(&self) -> String;
+
+    /// Return the full path to the directory the config file resides in
+    fn config_dir() -> PathBuf;
+
+    /// Return the full path to the config file
+    fn file_path(&self) -> PathBuf {
+        let mut config = Self::config_dir();
+        if !config.exists() {
+            create_dir(config.as_path())
+                .unwrap_or_else(|e| panic!("Could not create {:?} {e}", Self::config_dir()));
+        }
+        config.push(self.file_name());
+        let mut do_rename = !config.exists();
+        let mut cfg_old = config.clone();
+        // Migrating all configs to .ron format, so we do need to check for older ones
+        if do_rename {
+            warn!("Config {cfg_old:?} does not exist, looking for .cfg next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.cfg", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+            do_rename = false;
+        }
+        if do_rename && !cfg_old.exists() {
+            warn!("Config {cfg_old:?} does not exist, looking for .conf next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.conf", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+        }
+        config
+    }
+
+    /// Directly open the config file for read and write. If the config file
+    /// does not exist it is created, including the directories the file
+    /// resides in.
+    fn file_open(&self) -> File {
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(self.file_path())
+            .unwrap_or_else(|e| panic!("Could not open {:?} {e}", self.file_path()))
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read(&mut self) {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                *self = data;
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+    }
+
+    /// Write the config file data to pretty ron format
+    fn write(&self) {
+        let mut file = match File::create(self.file_path()) {
+            Ok(data) => data,
+            Err(e) => {
+                error!(
+                    "Couldn't overwrite config {:?}, error: {e}",
+                    self.file_path()
+                );
+                return;
+            }
+        };
+        let ron = match ron::ser::to_string_pretty(&self, PrettyConfig::new().depth_limit(4)) {
+            Ok(data) => data,
+            Err(e) => {
+                error!("Parse {:?} to RON failed, error: {e}", self.file_path());
+                return;
+            }
+        };
+        file.write_all(ron.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+
+    /// Renames the existing file to `<file>-old`
+    fn rename_file_old(&self) {
+        warn!(
+            "Renaming {} to {}-old and recreating config",
+            self.file_name(),
+            self.file_name()
+        );
+        let mut cfg_old = self.file_path().to_string_lossy().to_string();
+        cfg_old.push_str("-old");
+        std::fs::rename(self.file_path(), cfg_old).unwrap_or_else(|err| {
+            error!(
+                "Could not rename. Please remove {} then restart service: Error {}",
+                self.file_name(),
+                err
+            );
+        });
+    }
+}
+
+#[macro_export]
+macro_rules! std_config_load {
+    ($trait_name:ident: $($generic:ident),*) => {
+        /// Base trait for loading/parsing. This is intended to be used to help update
+        /// configs to new versions
+        ///
+        /// # Example
+        /// ```rust
+        /// use std::path::PathBuf;
+        /// use serde::{Deserialize, Serialize};
+        /// use config_traits::{StdConfig, StdConfigLoad2};
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOld {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOlder {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfig {}
+        ///
+        /// impl From<FanCurveConfigOld> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOld) -> Self { Self {} }
+        /// }
+        ///
+        /// impl From<FanCurveConfigOlder> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOlder) -> Self { Self {} }
+        /// }
+        ///
+        /// impl StdConfig for FanCurveConfig {
+        ///     fn new() -> Self { Self {} }
+        ///
+        ///     fn file_name(&self) -> std::string::String { "test_name.conf".to_owned() }
+        ///
+        ///     fn config_dir() -> PathBuf { PathBuf::from("/tmp") }
+        /// }
+        ///
+        /// impl StdConfigLoad2<FanCurveConfigOld, FanCurveConfigOlder> for FanCurveConfig {}
+        /// ```
+        ///
+        /// If all of the generics fails to parse, then the old config is renamed and a
+        /// new one created
+        pub trait $trait_name<$($generic),*>
+        where
+            Self: $crate::StdConfig +std::fmt::Debug + DeserializeOwned + Serialize,
+            $($generic: DeserializeOwned + Into<Self>),*
+        {
+            fn load(mut self) -> Self {
+                let mut file = self.file_open();
+                let mut buf = String::new();
+                if let Ok(read_len) = file.read_to_string(&mut buf) {
+                    if read_len != 0 {
+                        if let Ok(data) = ron::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed RON for {:?}", std::any::type_name::<Self>());
+                        } else if let Ok(data) = serde_json::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed JSON for {:?}", std::any::type_name::<Self>());
+                        } else if let Ok(data) = toml::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed TOML for {:?}", std::any::type_name::<Self>());
+                        } $(else if let Ok(data) = ron::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed RON for {:?}", std::any::type_name::<$generic>());
+                        } else if let Ok(data) = serde_json::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed JSON for {:?}", std::any::type_name::<$generic>());
+                        } else if let Ok(data) = toml::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("Newvious version failed, trying previous: Parsed TOML for {:?}", std::any::type_name::<$generic>());
+                        })* else {
+                            self.rename_file_old();
+                            self = Self::new();
+                        }
+                    } else {
+                        error!("Config file {} zero read length", self.file_name());
+                    }
+                }
+                self.write();
+                self
+            }
+        }
+    };
+}
+
+std_config_load!(StdConfigLoad:);
+std_config_load!(StdConfigLoad1: T1);
+std_config_load!(StdConfigLoad2: T1, T2);
+std_config_load!(StdConfigLoad3: T1, T2, T3);
+std_config_load!(StdConfigLoad4: T1, T2, T3, T4);
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    #[test]
+    fn check_macro_from_1() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad1<Old1> for Test {}
+    }
+
+    #[test]
+    fn check_macro_from_3() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old2 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old3 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old2> for Test {
+            fn from(_: Old2) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old3> for Test {
+            fn from(_: Old3) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad3<Old1, Old2, Old3> for Test {}
+    }
+}

daemon-user/src/user_config.rs

@@ -1,318 +0,0 @@
-use std::{
-    fs::{create_dir, OpenOptions},
-    io::{Read, Write},
-    time::Duration,
-};
-
-use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences, Vec2};
-use rog_aura::{keys::Key, Breathe, Colour, Effect, Flicker, LedType, Speed, Static};
-use serde::de::DeserializeOwned;
-use serde_derive::{Deserialize, Serialize};
-
-use crate::error::Error;
-
-pub trait ConfigLoadSave<T: DeserializeOwned + serde::Serialize> {
-    fn name(&self) -> String;
-
-    fn default_with_name(name: String) -> T;
-
-    fn write(&self) -> Result<(), Error>
-    where
-        Self: serde::Serialize,
-    {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-        let name = self.name();
-        path.push(name + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-
-    fn load(name: String) -> Result<T, Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push(name.clone() + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let default = Self::default_with_name(name);
-                let json = serde_json::to_string_pretty(&default).unwrap();
-                file.write_all(json.as_bytes())?;
-                return Ok(default);
-            } else if let Ok(data) = serde_json::from_str::<T>(&buf) {
-                return Ok(data);
-            }
-        }
-        Err(Error::ConfigLoadFail)
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UserAnimeConfig {
-    pub name: String,
-    pub anime: Vec<ActionLoader>,
-}
-
-impl UserAnimeConfig {
-    pub fn create(&self, anime_type: AnimeType) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new(anime_type);
-
-        for (idx, action) in self.anime.iter().enumerate() {
-            seq.insert(idx, action)?;
-        }
-
-        Ok(seq)
-    }
-}
-
-impl ConfigLoadSave<UserAnimeConfig> for UserAnimeConfig {
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    fn default_with_name(name: String) -> Self {
-        UserAnimeConfig {
-            name,
-            ..Default::default()
-        }
-    }
-}
-
-impl Default for UserAnimeConfig {
-    fn default() -> Self {
-        Self {
-            name: "default".to_string(),
-            anime: vec![
-                ActionLoader::AsusImage {
-                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
-                    brightness: 1.0,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        None,
-                        Duration::from_secs(2),
-                    )),
-                },
-                ActionLoader::AsusAnimation {
-                    file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
-                    brightness: 0.5,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(6),
-                        None,
-                        Duration::from_secs(3),
-                    )),
-                },
-                ActionLoader::ImageAnimation {
-                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                    scale: 0.9,
-                    angle: 0.65,
-                    translation: Vec2::default(),
-                    brightness: 0.5,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        Some(Duration::from_secs(2)),
-                        Duration::from_secs(2),
-                    )),
-                },
-                ActionLoader::Image {
-                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
-                    scale: 1.0,
-                    angle: 0.0,
-                    translation: Vec2::default(),
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        Some(Duration::from_secs(1)),
-                        Duration::from_secs(2),
-                    )),
-                    brightness: 0.6,
-                },
-                ActionLoader::Pause(Duration::from_secs(1)),
-                ActionLoader::ImageAnimation {
-                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
-                    scale: 0.9,
-                    angle: 0.0,
-                    translation: Vec2::new(3.0, 2.0),
-                    brightness: 0.5,
-                    time: AnimTime::Count(2),
-                },
-            ],
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UserAuraConfig {
-    pub name: String,
-    pub aura: rog_aura::Sequences,
-}
-
-impl ConfigLoadSave<UserAuraConfig> for UserAuraConfig {
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    fn default_with_name(name: String) -> Self {
-        UserAuraConfig {
-            name,
-            ..Default::default()
-        }
-    }
-}
-
-impl Default for UserAuraConfig {
-    fn default() -> Self {
-        let mut seq = rog_aura::Sequences::new();
-        let mut key = Effect::Breathe(Breathe::new(
-            LedType::Key(Key::W),
-            Colour(255, 0, 20),
-            Colour(20, 255, 0),
-            Speed::Low,
-        ));
-
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::A));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::S));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::D));
-        seq.push(key);
-
-        let key = Effect::Breathe(Breathe::new(
-            LedType::Key(Key::F),
-            Colour(255, 0, 0),
-            Colour(255, 0, 0),
-            Speed::High,
-        ));
-        seq.push(key);
-
-        let mut key = Effect::Static(Static::new(LedType::Key(Key::RCtrl), Colour(0, 0, 255)));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::LCtrl));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::Esc));
-        seq.push(key);
-
-        let key = Effect::Flicker(Flicker::new(
-            LedType::Key(Key::N9),
-            Colour(0, 0, 255),
-            80,
-            40,
-        ));
-        seq.push(key);
-
-        Self {
-            name: "default".to_string(),
-            aura: seq,
-        }
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-#[serde(default)]
-pub struct UserConfig {
-    /// Name of active anime config file in the user config directory
-    pub active_anime: Option<String>,
-    /// Name of active aura config file in the user config directory
-    pub active_aura: Option<String>,
-}
-
-impl UserConfig {
-    pub fn new() -> Self {
-        Self {
-            active_anime: Some("anime-default".to_string()),
-            active_aura: Some("aura-default".to_string()),
-        }
-    }
-
-    pub fn load(&mut self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let json = serde_json::to_string_pretty(&self).unwrap();
-                file.write_all(json.as_bytes())?;
-            } else if let Ok(data) = serde_json::from_str::<UserConfig>(&buf) {
-                self.active_anime = data.active_anime;
-                self.active_aura = data.active_aura;
-                return Ok(());
-            }
-        }
-        Ok(())
-    }
-
-    pub fn write(&self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-}

daemon/src/config.rs

@@ -1,83 +0,0 @@
-use log::{error, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-use std::path::PathBuf;
-
-pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-
-#[derive(Deserialize, Serialize, Default)]
-#[serde(default)]
-pub struct Config {
-    /// Save charge limit for restoring on boot
-    pub bat_charge_limit: u8,
-    pub panel_od: bool,
-}
-
-impl Config {
-    fn new() -> Self {
-        Config {
-            bat_charge_limit: 100,
-            panel_od: false,
-        }
-    }
-
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load() -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&PathBuf::from(CONFIG_PATH))
-            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
-        let mut buf = String::new();
-        let config;
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                config = Self::new();
-            } else if let Ok(data) = serde_json::from_str(&buf) {
-                config = data;
-            } else {
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    CONFIG_PATH, CONFIG_PATH
-                );
-                let cfg_old = CONFIG_PATH.to_string() + "-old";
-                std::fs::rename(CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        CONFIG_PATH, err
-                    )
-                });
-                config = Self::new();
-            }
-        } else {
-            config = Self::new()
-        }
-        config.write();
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", CONFIG_PATH);
-            } else {
-                *self = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_anime/config.rs

@@ -1,272 +0,0 @@
-use crate::VERSION;
-use log::{error, info, warn};
-use rog_anime::{error::AnimeError, ActionData, ActionLoader, AnimTime, Vec2};
-use rog_anime::{AnimeType, Fade};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-use std::time::Duration;
-
-pub static ANIME_CONFIG_PATH: &str = "/etc/asusd/anime.conf";
-pub static ANIME_CACHE_PATH: &str = "/etc/asusd/anime-cache.conf";
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV341 {
-    pub system: Option<ActionLoader>,
-    pub boot: Option<ActionLoader>,
-    pub suspend: Option<ActionLoader>,
-    pub shutdown: Option<ActionLoader>,
-}
-
-impl AnimeConfigV341 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: if let Some(ani) = self.system {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            boot: if let Some(ani) = self.boot {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            wake: if let Some(ani) = self.suspend {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            shutdown: if let Some(ani) = self.shutdown {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV352 {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-}
-
-impl AnimeConfigV352 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: self.system,
-            boot: self.boot,
-            wake: self.wake,
-            shutdown: self.shutdown,
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Default)]
-pub struct AnimeConfigCached {
-    pub system: Vec<ActionData>,
-    pub boot: Vec<ActionData>,
-    pub wake: Vec<ActionData>,
-    pub shutdown: Vec<ActionData>,
-}
-
-impl AnimeConfigCached {
-    pub fn init_from_config(
-        &mut self,
-        config: &AnimeConfig,
-        anime_type: AnimeType,
-    ) -> Result<(), AnimeError> {
-        let mut sys = Vec::with_capacity(config.system.len());
-        for ani in config.system.iter() {
-            sys.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.system = sys;
-
-        let mut boot = Vec::with_capacity(config.boot.len());
-        for ani in config.boot.iter() {
-            boot.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.boot = boot;
-
-        let mut wake = Vec::with_capacity(config.wake.len());
-        for ani in config.wake.iter() {
-            wake.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.wake = wake;
-
-        let mut shutdown = Vec::with_capacity(config.shutdown.len());
-        for ani in config.shutdown.iter() {
-            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.shutdown = shutdown;
-        Ok(())
-    }
-}
-
-/// Config for base system actions for the anime display
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfig {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-    pub awake_enabled: bool,
-    pub boot_anim_enabled: bool,
-}
-
-impl Default for AnimeConfig {
-    fn default() -> Self {
-        AnimeConfig {
-            system: Vec::new(),
-            boot: Vec::new(),
-            wake: Vec::new(),
-            shutdown: Vec::new(),
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-impl AnimeConfig {
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load() -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&ANIME_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    ANIME_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                return AnimeConfig::create_default(&mut file);
-            } else {
-                if let Ok(mut data) = serde_json::from_str(&buf) {
-                    Self::clamp_config_brightness(&mut data);
-                    return data;
-                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV341>(&buf) {
-                    let mut config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    Self::clamp_config_brightness(&mut config);
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV352>(&buf) {
-                    let mut config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    Self::clamp_config_brightness(&mut config);
-                    return config;
-                }
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    ANIME_CONFIG_PATH, ANIME_CONFIG_PATH
-                );
-                let cfg_old = ANIME_CONFIG_PATH.to_string() + "-old";
-                std::fs::rename(ANIME_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        ANIME_CONFIG_PATH, err
-                    )
-                });
-            }
-        }
-        AnimeConfig::create_default(&mut file)
-    }
-
-    fn clamp_config_brightness(mut config: &mut AnimeConfig) {
-        if config.brightness < 0.0 || config.brightness > 1.0 {
-            warn!(
-                "Clamped brightness to [0.0 ; 1.0], was {}",
-                config.brightness
-            );
-            config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
-        }
-    }
-
-    fn create_default(file: &mut File) -> Self {
-        // create a default config here
-        let config = AnimeConfig {
-            system: vec![],
-            boot: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            wake: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            shutdown: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
-                scale: 0.9,
-                angle: 0.0,
-                translation: Vec2::new(3.0, 2.0),
-                brightness: 1.0,
-                time: AnimTime::Infinite,
-            }],
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        };
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", ANIME_CONFIG_PATH));
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&ANIME_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", ANIME_CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", ANIME_CONFIG_PATH);
-            } else {
-                let x: AnimeConfig = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", ANIME_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(ANIME_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_anime/trait_impls.rs

@@ -1,216 +0,0 @@
-use super::CtrlAnime;
-use crate::error::RogError;
-use async_trait::async_trait;
-use log::{info, warn};
-use rog_anime::{
-    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
-    AnimeDataBuffer, AnimePowerStates,
-};
-use std::sync::{atomic::Ordering, Arc};
-use zbus::{
-    dbus_interface,
-    export::futures_util::lock::{Mutex, MutexGuard},
-    Connection, SignalContext,
-};
-
-pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Anime";
-
-#[derive(Clone)]
-pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
-
-/// The struct with the main dbus methods requires this trait
-#[async_trait]
-impl crate::ZbusRun for CtrlAnimeZbus {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
-    }
-}
-
-// None of these calls can be guarnateed to succeed unless we loop until okay
-// If the try_lock *does* succeed then any other thread trying to lock will not grab it
-// until we finish.
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlAnimeZbus {
-    /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
-        let lock = self.0.lock().await;
-        lock.thread_exit.store(true, Ordering::SeqCst);
-        lock.write_data_buffer(input).map_err(|err| {
-            warn!("rog_anime::run_animation:callback {}", err);
-            err
-        })?;
-        Ok(())
-    }
-
-    /// Set the global AniMe brightness
-    async fn set_brightness(&self, bright: f32) {
-        let mut lock = self.0.lock().await;
-        let mut bright = bright;
-        if bright < 0.0 {
-            bright = 0.0
-        } else if bright > 1.0 {
-            bright = 1.0;
-        }
-        lock.config.brightness = bright;
-        lock.config.write();
-    }
-
-    /// Set whether the AniMe is displaying images/data
-    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
-        let mut lock = self.0.lock().await;
-        lock.node
-            .write_bytes(&pkt_for_set_on(status))
-            .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
-            })
-            .ok();
-        lock.config.awake_enabled = status;
-        lock.config.write();
-
-        Self::notify_power_states(
-            &ctxt,
-            AnimePowerStates {
-                brightness: lock.config.brightness.floor() as u8,
-                enabled: lock.config.awake_enabled,
-                boot_anim_enabled: lock.config.boot_anim_enabled,
-            },
-        )
-        .await
-        .ok();
-    }
-
-    /// Set whether the AniMe will show boot, suspend, or off animations
-    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
-        let mut lock = self.0.lock().await;
-        lock.node
-            .write_bytes(&pkt_for_set_boot(on))
-            .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
-            })
-            .ok();
-        lock.node
-            .write_bytes(&pkt_for_apply())
-            .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
-            })
-            .ok();
-        lock.config.boot_anim_enabled = on;
-        lock.config.write();
-
-        Self::notify_power_states(
-            &ctxt,
-            AnimePowerStates {
-                brightness: lock.config.brightness.floor() as u8,
-                enabled: lock.config.awake_enabled,
-                boot_anim_enabled: lock.config.boot_anim_enabled,
-            },
-        )
-        .await
-        .ok();
-    }
-
-    /// The main loop is the base system set action if the user isn't running
-    /// the user daemon
-    async fn run_main_loop(&self, start: bool) {
-        if start {
-            let lock = self.0.lock().await;
-            lock.thread_exit.store(true, Ordering::SeqCst);
-            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
-        }
-    }
-
-    /// Get status of if the AniMe LEDs are on/displaying while system is awake
-    #[dbus_interface(property)]
-    async fn awake_enabled(&self) -> bool {
-        let lock = self.0.lock().await;
-        lock.config.awake_enabled
-    }
-
-    /// Get the status of if factory system-status animations are enabled
-    #[dbus_interface(property)]
-    async fn boot_enabled(&self) -> bool {
-        let lock = self.0.lock().await;
-        lock.config.boot_anim_enabled
-    }
-
-    /// Notify listeners of the status of AniMe LED power and factory system-status animations
-    #[dbus_interface(signal)]
-    async fn notify_power_states(
-        ctxt: &SignalContext<'_>,
-        data: AnimePowerStates,
-    ) -> zbus::Result<()>;
-}
-
-#[async_trait]
-impl crate::CtrlTask for CtrlAnimeZbus {
-    fn zbus_path() -> &'static str {
-        ZBUS_PATH
-    }
-
-    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
-        let run_action =
-            |start: bool, lock: MutexGuard<CtrlAnime>, inner: Arc<Mutex<CtrlAnime>>| {
-                if start {
-                    info!("CtrlAnimeTask running sleep animation");
-                    CtrlAnime::run_thread(inner, lock.cache.shutdown.clone(), true);
-                } else {
-                    info!("CtrlAnimeTask running wake animation");
-                    CtrlAnime::run_thread(inner, lock.cache.wake.clone(), true);
-                }
-            };
-
-        let inner1 = self.0.clone();
-        let inner2 = self.0.clone();
-        let inner3 = self.0.clone();
-        let inner4 = self.0.clone();
-        self.create_sys_event_tasks(
-            // Loop is required to try an attempt to get the mutex *without* blocking
-            // other threads - it is possible to end up with deadlocks otherwise.
-            move || loop {
-                if let Some(lock) = inner1.try_lock() {
-                    run_action(true, lock, inner1.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Some(lock) = inner2.try_lock() {
-                    run_action(false, lock, inner2.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Some(lock) = inner3.try_lock() {
-                    run_action(true, lock, inner3.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Some(lock) = inner4.try_lock() {
-                    run_action(false, lock, inner4.clone());
-                    break;
-                }
-            },
-        )
-        .await;
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl crate::Reloadable for CtrlAnimeZbus {
-    async fn reload(&mut self) -> Result<(), RogError> {
-        if let Some(lock) = self.0.try_lock() {
-            lock.node
-                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
-            lock.node.write_bytes(&pkt_for_apply())?;
-            lock.node
-                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
-            lock.node.write_bytes(&pkt_for_apply())?;
-
-            let action = lock.cache.boot.clone();
-            CtrlAnime::run_thread(self.0.clone(), action, true);
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/config.rs

@@ -1,87 +0,0 @@
-use log::{error, warn};
-use rog_profiles::{FanCurveProfiles, Profile};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ProfileConfig {
-    #[serde(skip)]
-    config_path: String,
-    /// For restore on boot
-    pub active_profile: Profile,
-    /// States to restore
-    pub fan_curves: Option<FanCurveProfiles>,
-}
-
-impl ProfileConfig {
-    fn new(config_path: String) -> Self {
-        Self {
-            config_path,
-            active_profile: Profile::Balanced,
-            fan_curves: None,
-        }
-    }
-
-    pub fn load(config_path: String) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&config_path)
-            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
-        let mut buf = String::new();
-        let mut config;
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                config = Self::new(config_path);
-            } else if let Ok(data) = toml::from_str(&buf) {
-                config = data;
-                config.config_path = config_path;
-            } else {
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    config_path, config_path
-                );
-                let cfg_old = config_path.clone() + "-old";
-                std::fs::rename(config_path.clone(), cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        config_path, err
-                    )
-                });
-                config = Self::new(config_path);
-            }
-        } else {
-            config = Self::new(config_path);
-        }
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.config_path)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", self.config_path, err));
-
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", self.config_path);
-            } else {
-                let mut data: ProfileConfig = toml::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", self.config_path));
-                // copy over serde skipped values
-                data.config_path = self.config_path.clone();
-                *self = data;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(&self.config_path).expect("Couldn't overwrite config");
-        let data = toml::to_string(self).expect("Parse config to toml failed");
-        file.write_all(data.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_profiles/controller.rs

@@ -1,116 +0,0 @@
-use crate::error::RogError;
-use crate::GetSupported;
-use log::{info, warn};
-use rog_platform::platform::AsusPlatform;
-use rog_platform::supported::PlatformProfileFunctions;
-use rog_profiles::error::ProfileError;
-use rog_profiles::{FanCurveProfiles, Profile};
-
-use super::config::ProfileConfig;
-
-pub struct CtrlPlatformProfile {
-    pub config: ProfileConfig,
-    pub platform: AsusPlatform,
-}
-
-impl GetSupported for CtrlPlatformProfile {
-    type A = PlatformProfileFunctions;
-
-    fn get_supported() -> Self::A {
-        if !Profile::is_platform_profile_supported() {
-            warn!("platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.");
-        }
-
-        let res = FanCurveProfiles::is_supported();
-        let mut fan_curve_supported = res.is_err();
-        if let Ok(r) = res {
-            fan_curve_supported = r;
-        };
-
-        if !fan_curve_supported {
-            info!("fan curves kernel interface not found, your laptop does not support this, or the interface is missing.");
-        }
-
-        PlatformProfileFunctions {
-            platform_profile: Profile::is_platform_profile_supported(),
-            fan_curves: fan_curve_supported,
-        }
-    }
-}
-
-impl CtrlPlatformProfile {
-    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
-        let platform = AsusPlatform::new()?;
-        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
-            info!("Device has profile control available");
-
-            let mut controller = CtrlPlatformProfile { config, platform };
-            if FanCurveProfiles::get_device().is_ok() {
-                info!("Device has fan curves available");
-                if controller.config.fan_curves.is_none() {
-                    controller.config.fan_curves = Some(Default::default());
-                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
-                        controller.set_next_profile()?;
-                        controller.set_active_curve_to_defaults()?;
-
-                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-                        if let Some(curves) = controller.config.fan_curves.as_ref() {
-                            info!(
-                                "{active:?}: {}",
-                                String::from(curves.get_fan_curves_for(active))
-                            );
-                        }
-                    }
-                }
-            }
-
-            return Ok(controller);
-        }
-
-        Err(ProfileError::NotSupported.into())
-    }
-
-    pub fn save_config(&self) {
-        self.config.write();
-    }
-
-    /// Toggle to next profile in list. This will first read the config, switch, then write out
-    pub(super) fn set_next_profile(&mut self) -> Result<(), RogError> {
-        // Read first just incase the user has modified the config before calling this
-        match self.config.active_profile {
-            Profile::Balanced => {
-                Profile::set_profile(Profile::Performance)?;
-                self.config.active_profile = Profile::Performance;
-            }
-            Profile::Performance => {
-                Profile::set_profile(Profile::Quiet)?;
-                self.config.active_profile = Profile::Quiet;
-            }
-            Profile::Quiet => {
-                Profile::set_profile(Profile::Balanced)?;
-                self.config.active_profile = Profile::Balanced;
-            }
-        }
-        self.write_profile_curve_to_platform()?;
-        Ok(())
-    }
-
-    /// Set the curve for the active profile active
-    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = &mut self.config.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = self.config.fan_curves.as_mut() {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.set_active_curve_to_defaults(self.config.active_profile, &mut device)?;
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/trait_impls.rs

@@ -1,246 +0,0 @@
-use async_trait::async_trait;
-use log::warn;
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::fan_curve_set::FanCurveSet;
-use rog_profiles::FanCurveProfiles;
-use rog_profiles::Profile;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::export::futures_util::StreamExt;
-use zbus::Connection;
-use zbus::SignalContext;
-
-use std::sync::Arc;
-use zbus::{dbus_interface, fdo::Error};
-
-use crate::error::RogError;
-use crate::CtrlTask;
-
-use super::controller::CtrlPlatformProfile;
-
-const ZBUS_PATH: &str = "/org/asuslinux/Profile";
-const UNSUPPORTED_MSG: &str =
-    "Fan curves are not supported on this laptop or you require a patched kernel";
-
-#[derive(Clone)]
-pub struct ProfileZbus(pub Arc<Mutex<CtrlPlatformProfile>>);
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl ProfileZbus {
-    /// Fetch profile names
-    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(profiles) = Profile::get_profile_names() {
-            return Ok(profiles);
-        }
-        Err(Error::Failed(
-            "Failed to get all profile details".to_string(),
-        ))
-    }
-
-    /// Toggle to next platform_profile. Names provided by `Profiles`.
-    /// If fan-curves are supported will also activate a fan curve for profile.
-    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
-        let mut ctrl = self.0.lock().await;
-        ctrl.set_next_profile()
-            .unwrap_or_else(|err| warn!("{}", err));
-        ctrl.save_config();
-
-        Self::notify_profile(&ctxt, ctrl.config.active_profile)
-            .await
-            .ok();
-    }
-
-    /// Fetch the active profile name
-    async fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        Ok(ctrl.config.active_profile)
-    }
-
-    /// Set this platform_profile name as active
-    async fn set_active_profile(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        profile: Profile,
-    ) {
-        let mut ctrl = self.0.lock().await;
-        // Read first just incase the user has modified the config before calling this
-        ctrl.config.read();
-        Profile::set_profile(profile)
-            .map_err(|e| warn!("set_profile, {}", e))
-            .ok();
-        ctrl.config.active_profile = profile;
-        ctrl.write_profile_curve_to_platform()
-            .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-            .ok();
-
-        ctrl.save_config();
-
-        Self::notify_profile(&ctxt, ctrl.config.active_profile)
-            .await
-            .ok();
-    }
-
-    /// Get a list of profiles that have fan-curves enabled.
-    async fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        if let Some(curves) = &ctrl.config.fan_curves {
-            return Ok(curves.get_enabled_curve_profiles().to_vec());
-        }
-        Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
-    }
-
-    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
-    /// same profile mode
-    async fn set_fan_curve_enabled(
-        &mut self,
-        profile: Profile,
-        enabled: bool,
-    ) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        if let Some(curves) = &mut ctrl.config.fan_curves {
-            curves.set_profile_curve_enabled(profile, enabled);
-
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-                .ok();
-
-            ctrl.save_config();
-            Ok(())
-        } else {
-            Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
-        }
-    }
-
-    /// Get the fan-curve data for the currently active Profile
-    async fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        if let Some(curves) = &ctrl.config.fan_curves {
-            let curve = curves.get_fan_curves_for(profile);
-            return Ok(curve.clone());
-        }
-        Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
-    }
-
-    /// Set the fan curve for the specified profile.
-    /// Will also activate the fan curve if the user is in the same mode.
-    async fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        if let Some(curves) = &mut ctrl.config.fan_curves {
-            curves
-                .save_fan_curve(curve, profile)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-        } else {
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-        }
-        ctrl.write_profile_curve_to_platform()
-            .map_err(|e| warn!("Profile::set_profile, {}", e))
-            .ok();
-        ctrl.save_config();
-
-        Ok(())
-    }
-
-    /// Reset the stored (self) and device curve to the defaults of the platform.
-    ///
-    /// Each platform_profile has a different default and the defualt can be read
-    /// only for the currently active profile.
-    async fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        ctrl.set_active_curve_to_defaults()
-            .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
-            .ok();
-        ctrl.save_config();
-        Ok(())
-    }
-
-    /// Reset the stored (self) and device curve to the defaults of the platform.
-    ///
-    /// Each platform_profile has a different default and the defualt can be read
-    /// only for the currently active profile.
-    async fn reset_profile_curves(&self, profile: Profile) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.config.read();
-        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-
-        Profile::set_profile(profile)
-            .map_err(|e| warn!("set_profile, {}", e))
-            .ok();
-        ctrl.set_active_curve_to_defaults()
-            .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
-            .ok();
-
-        Profile::set_profile(active)
-            .map_err(|e| warn!("set_profile, {}", e))
-            .ok();
-        ctrl.save_config();
-        Ok(())
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
-    }
-}
-
-#[async_trait]
-impl crate::ZbusRun for ProfileZbus {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
-    }
-}
-
-#[async_trait]
-impl CtrlTask for ProfileZbus {
-    fn zbus_path() -> &'static str {
-        ZBUS_PATH
-    }
-
-    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
-        let ctrl = self.0.clone();
-        let mut watch = self.0.lock().await.platform.monitor_platform_profile()?;
-
-        tokio::spawn(async move {
-            let mut buffer = [0; 32];
-            watch
-                .event_stream(&mut buffer)
-                .unwrap()
-                .for_each(|_| async {
-                    let mut lock = ctrl.lock().await;
-                    let new_profile = Profile::get_active_profile().unwrap();
-                    if new_profile != lock.config.active_profile {
-                        lock.config.active_profile = new_profile;
-                        lock.write_profile_curve_to_platform().unwrap();
-                        lock.save_config();
-                    }
-                    Self::notify_profile(&signal_ctxt.clone(), lock.config.active_profile)
-                        .await
-                        .ok();
-                })
-                .await;
-        });
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl crate::Reloadable for ProfileZbus {
-    /// Fetch the active profile and use that to set all related components up
-    async fn reload(&mut self) -> Result<(), RogError> {
-        let mut ctrl = self.0.lock().await;
-        let active = ctrl.config.active_profile;
-        if let Some(curves) = &mut ctrl.config.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                // There is a possibility that the curve was default zeroed, so this call initialises
-                // the data from system read and we need to save it after
-                curves.write_profile_curve_to_platform(active, &mut device)?;
-                ctrl.config.write();
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/laptops.rs

@@ -1,167 +0,0 @@
-use log::{info, warn};
-use rog_aura::{AuraModeNum, AuraZone};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub const ASUS_LED_MODE_CONF: &str = "/etc/asusd/asusd-ledmodes.toml";
-pub const ASUS_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd-user-ledmodes.toml";
-pub const ASUS_KEYBOARD_DEVICES: [&str; 4] = ["1866", "1869", "1854", "19b6"];
-
-pub fn print_board_info() {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-
-    info!("Product family: {}", prod_family.trim());
-    info!("Board name: {}", board_name.trim());
-}
-
-pub fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModeNum>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect you can edit {}",
-            ASUS_LED_MODE_CONF
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-struct LedSupportFile {
-    led_data: Vec<LaptopLedData>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-#[serde(default)]
-pub struct LaptopLedData {
-    pub prod_family: String,
-    pub board_names: Vec<String>,
-    pub standard: Vec<AuraModeNum>,
-    pub multizone: Vec<AuraZone>,
-    pub per_key: bool,
-}
-
-impl LaptopLedData {
-    pub fn get_data() -> Self {
-        let dmi = sysfs_class::DmiId::default();
-        let board_name = dmi.board_name().expect("Could not get board_name");
-        let prod_family = dmi.product_family().expect("Could not get product_family");
-
-        if let Some(modes) = LedSupportFile::load_from_config() {
-            if let Some(data) = modes.matcher(&prod_family, &board_name) {
-                return data;
-            }
-        }
-        info!("Using generic LED control for keyboard brightness only");
-        LaptopLedData {
-            prod_family,
-            board_names: vec![board_name],
-            standard: vec![],
-            multizone: vec![],
-            per_key: false,
-        }
-    }
-}
-
-impl LedSupportFile {
-    /// Consumes the LEDModes
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<LaptopLedData> {
-        for config in self.led_data {
-            if prod_family.contains(&config.prod_family) {
-                for board in &config.board_names {
-                    if board_name.contains(board) {
-                        info!("Matched to {} {}", config.prod_family, board);
-                        return Some(config);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        let mut loaded = false;
-        let mut data = LedSupportFile::default();
-        // Load user configs first so they are first to be checked
-        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_USER_CONF) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", ASUS_LED_MODE_USER_CONF);
-                } else {
-                    if let Ok(mut tmp) = toml::from_str::<LedSupportFile>(&buf) {
-                        data.led_data.append(&mut tmp.led_data);
-                    }
-                    info!(
-                        "Loaded user-defined LED support data from {}",
-                        ASUS_LED_MODE_USER_CONF
-                    );
-                }
-            }
-        }
-        // Load and append the default LED support data
-        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_CONF) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", ASUS_LED_MODE_CONF);
-                } else {
-                    let mut tmp: LedSupportFile = toml::from_str(&buf)
-                        .unwrap_or_else(|_| panic!("Could not deserialise {}", ASUS_LED_MODE_CONF));
-                    data.led_data.append(&mut tmp.led_data);
-                    loaded = true;
-                    info!(
-                        "Loaded default LED support data from {}",
-                        ASUS_LED_MODE_CONF
-                    );
-                }
-            }
-        }
-
-        if loaded {
-            return Some(data);
-        }
-
-        warn!("Does {} exist?", ASUS_LED_MODE_USER_CONF);
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{fs::OpenOptions, io::Read, path::PathBuf};
-
-    use super::LaptopLedData;
-    use rog_aura::{AuraModeNum, AuraZone};
-
-    #[test]
-    fn check_data_parse() {
-        let led = LaptopLedData {
-            prod_family: "Test".to_owned(),
-            board_names: vec!["Test".to_owned()],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![AuraZone::Key1, AuraZone::Logo, AuraZone::BarLeft],
-            per_key: false,
-        };
-
-        let toml = toml::to_string_pretty(&led).unwrap();
-        println!("{toml}");
-
-        let mut data = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        data.push("../data/asusd-ledmodes.toml");
-
-        let mut file = OpenOptions::new().read(true).open(&data).unwrap();
-        let mut buf = String::new();
-        file.read_to_string(&mut buf).unwrap();
-
-        let x = toml::to_string_pretty(&buf).unwrap();
-        println!("{x}");
-    }
-}

daemon/src/systemd.rs

@@ -1,90 +0,0 @@
-use std::process::Command;
-
-use crate::error::RogError;
-
-/// An action for `systemctl`
-#[derive(Debug, Copy, Clone)]
-pub enum SystemdUnitAction {
-    Stop,
-    Start,
-    Restart,
-}
-
-impl From<SystemdUnitAction> for &str {
-    fn from(s: SystemdUnitAction) -> Self {
-        match s {
-            SystemdUnitAction::Stop => "stop",
-            SystemdUnitAction::Start => "start",
-            SystemdUnitAction::Restart => "restart",
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum SystemdUnitState {
-    Active,
-    Inactive,
-}
-
-impl From<SystemdUnitState> for &str {
-    fn from(s: SystemdUnitState) -> Self {
-        match s {
-            SystemdUnitState::Active => "active",
-            SystemdUnitState::Inactive => "inactive",
-        }
-    }
-}
-
-/// Change the state of a systemd unit. Blocks while running command.
-pub fn do_systemd_unit_action(action: SystemdUnitAction, unit: &str) -> Result<(), RogError> {
-    let mut cmd = Command::new("systemctl");
-    cmd.arg(<&str>::from(action));
-    cmd.arg(unit);
-
-    let status = cmd
-        .status()
-        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
-    if !status.success() {
-        let msg = format!("systemctl {action:?} {unit} failed: {status:?}",);
-        return Err(RogError::SystemdUnitAction(msg));
-    }
-    Ok(())
-}
-
-/// Get systemd unit state. Blocks while command is run.
-pub fn is_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<bool, RogError> {
-    let mut cmd = Command::new("systemctl");
-    cmd.arg("is-active");
-    cmd.arg(unit);
-
-    let output = cmd
-        .output()
-        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
-    if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
-        return Ok(true);
-    }
-    Ok(false)
-}
-
-/// Wait for a systemd unit to change to `state`. Checks state every 250ms for 3 seconds. Blocks while running wait.
-pub fn wait_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<(), RogError> {
-    let mut cmd = Command::new("systemctl");
-    cmd.arg("is-active");
-    cmd.arg(unit);
-
-    let mut count = 0;
-
-    while count <= (4 * 3) {
-        // 3 seconds max
-        let output = cmd
-            .output()
-            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
-        if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
-            return Ok(());
-        }
-        // fine to block here, nobody doing shit now
-        std::thread::sleep(std::time::Duration::from_millis(250));
-        count += 1;
-    }
-    Err(RogError::SystemdUnitWaitTimeout(<&str>::from(state).into()))
-}

data/asusd-ledmodes.toml

@@ -1,197 +0,0 @@
-[[led_data]]
-prod_family = "TUF"
-board_names = ["FA507"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "TUF Gaming"
-board_names = ["FX505D"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ASUS TUF Gaming A15"
-board_names = ["FA506I"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "Zephyrus S"
-board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "Zephyrus M"
-board_names = ["GU502G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502L"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus M16"
-board_names = ["GU603Z", "GU603H"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus S17"
-board_names = ["GX703H"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = false
-
-
-[[led_data]]
-prod_family = "Zephyrus"
-board_names = ["GM501G", "GX531"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G531GW", "G533QR", "G533QS", "G733Q", "G513QR", "G713QR", "G513QM", "G713IC", "G713RS"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512", "G713RW"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G512LI", "G712LI", "G531GD"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513IM"]
-standard = ["Flash", "Static", "Breathe", "Strobe", "Rainbow"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GV", "G731GW", "G531GV"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["GL504G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "Strix Scar"
-board_names = ["G531", "G731"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = true
-
-[[led_data]]
-prod_family = "ROG"
-board_names = ["GL553VE"]
-standard = ["Static", "Breathe", "Strobe"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G14"
-board_names = ["GA401Q"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G14"
-board_names = ["GA402R"]
-standard = ["Static", "Breathe", "Pulse", "Rainbow"]
-multizone = []
-per_key = false
-
-# GA503QE at higher priority (first match) than GA503Q
-[[led_data]]
-prod_family = "ROG Zephyrus G15"
-board_names = ["GA503QE"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G15"
-board_names = ["GA503Q", "GA503R"]
-standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus"
-board_names = ["GX550L"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus Duo 15 SE"
-board_names = ["GX551Q"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Flow X13"
-board_names = ["GV301Q"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513IC", "G513RC"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Flow X16"
-board_names = ["GV601R"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false

data/asusd.rules

@@ -9,7 +9,7 @@ ENV{DMI_FAMILY}=="*TUF*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*ROG*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Zephyrus*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Strix*", GOTO="asusd_start"
-ENV{DMI_FAMILY}=="*Vivobook*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Vivo*ook*", GOTO="asusd_start"
 # No match so
 GOTO="asusd_end"
 
@@ -17,4 +17,4 @@ LABEL="asusd_start"
 ACTION=="add|change", DRIVER=="asus-nb-wmi", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
 ACTION=="add|remove", DRIVER=="asus-nb-wmi", TAG+="systemd", RUN+="systemctl restart asusd.service"
 
-LABEL="asusd_end"
+LABEL="asusd_end"

data/asusd.service

@@ -3,13 +3,15 @@ Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
 Before=multi-user.target
+After=power-profiles-daemon.service
+After=nvidia-powerd.service
 
 [Service]
 Environment=IS_SERVICE=1
+Environment=RUST_LOG="info"
 ExecStartPre=/bin/sleep 2
 ExecStart=/usr/bin/asusd
 Restart=on-failure
-Restart=always
 RestartSec=1
 Type=dbus
 BusName=org.asuslinux.Daemon

deny.toml

@@ -0,0 +1,69 @@
+# https://embarkstudios.github.io/cargo-deny/
+
+targets = [
+    { triple = "aarch64-apple-darwin" },
+    { triple = "aarch64-linux-android" },
+    { triple = "wasm32-unknown-unknown" },
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-linux-musl" },
+]
+
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+ignore = [
+    "RUSTSEC-2020-0071", # https://rustsec.org/advisories/RUSTSEC-2020-0071 - chrono/time: Potential segfault in the time crate
+    "RUSTSEC-2020-0159", # https://rustsec.org/advisories/RUSTSEC-2020-0159 - chrono/time: Potential segfault in localtime_r invocations
+    "RUSTSEC-2021-0127", # https://rustsec.org/advisories/RUSTSEC-2021-0127 - https://github.com/bheisler/criterion.rs/issues/534
+]
+
+[bans]
+multiple-versions = "deny"
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+deny = [
+    { name = "openssl" },     # prefer rustls
+    { name = "openssl-sys" }, # prefer rustls
+]
+
+skip-tree = [
+    { name = "criterion" }, # dev-dependency
+    { name = "glium" },     # legacy crate, lots of old dependencies
+    { name = "rfd" },       # example dependency
+    { name = "three-d" },   # example dependency
+]
+
+
+[licenses]
+unlicensed = "deny"
+allow-osi-fsf-free = "neither"
+confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
+copyleft = "deny"
+allow = [
+    "Apache-2.0",         # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause",       # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause",       # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "BSL-1.0",            # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "CC0-1.0",            # https://creativecommons.org/publicdomain/zero/1.0/
+    "ISC",                # https://tldrlegal.com/license/-isc-license
+    "LicenseRef-UFL-1.0", # https://tldrlegal.com/license/ubuntu-font-license,-1.0 - no official SPDX, see https://github.com/emilk/egui/issues/2321
+    "MIT",                # https://tldrlegal.com/license/mit-license
+    "MPL-2.0",            # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11
+    "OFL-1.1",            # https://spdx.org/licenses/OFL-1.1.html
+    "OpenSSL",            # https://www.openssl.org/source/license.html
+    "Unicode-DFS-2016",   # https://spdx.org/licenses/Unicode-DFS-2016.html
+    "Zlib",               # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+]
+
+[[licenses.clarify]]
+name = "webpki"
+expression = "ISC"
+license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
+

extra/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+    <script language="javascript" type="text/javascript">
+     <!--
+            window.setTimeout('window.location="room4doom/index.html"; ', 0);
+     // -->
+    </script>
+</body>
+
+</html>

rog-anime/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rog_anime"
-version.workspace = true
 license = "MPL-2.0"
+version.workspace = true
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
@@ -14,9 +14,13 @@ exclude = ["data"]
 
 [features]
 default = ["dbus", "detect"]
-dbus = ["zvariant", "zbus"]
+dbus = ["zbus"]
 detect = ["sysfs-class"]
 
+[lib]
+name = "rog_anime"
+path = "src/lib.rs"
+
 [dependencies]
 png_pong.workspace = true
 pix.workspace = true
@@ -28,7 +32,9 @@ serde_derive.workspace = true
 
 glam.workspace = true
 
-zvariant = { workspace = true, optional = true }
 zbus = { workspace = true, optional = true }
 
-sysfs-class = { workspace = true, optional = true }
+sysfs-class = { workspace = true, optional = true }
+
+[dev-dependencies]
+cargo-husky.workspace = true

rog-anime/src/data.rs

@@ -1,20 +1,19 @@
-use std::{
-    convert::TryFrom,
-    thread::sleep,
-    time::{Duration, Instant},
-};
+use std::convert::TryFrom;
+use std::str::FromStr;
+use std::thread::sleep;
+use std::time::{Duration, Instant};
 
 use log::info;
 use serde_derive::{Deserialize, Serialize};
 #[cfg(feature = "dbus")]
-use zvariant::Type;
+use zbus::zvariant::Type;
 
-use crate::{
-    error::{AnimeError, Result},
-    AnimTime, AnimeGif,
-};
+use crate::error::{AnimeError, Result};
+use crate::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
+use crate::{AnimTime, AnimeGif};
 
-/// The first 7 bytes of a USB packet are accounted for by `USB_PREFIX1` and `USB_PREFIX2`
+/// The first 7 bytes of a USB packet are accounted for by `USB_PREFIX1` and
+/// `USB_PREFIX2`
 const BLOCK_START: usize = 7;
 /// *Not* inclusive, the byte before this is the final for each "pane"
 const BLOCK_END: usize = 634;
@@ -22,18 +21,28 @@ const BLOCK_END: usize = 634;
 const PANE_LEN: usize = BLOCK_END - BLOCK_START;
 
 /// First packet is for GA401 + GA402
-const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
+pub const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
 /// Second packet is for GA401 + GA402
-const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
+pub const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
 /// Third packet is for GA402 matrix
-const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
+pub const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
+
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Default, Deserialize, PartialEq, Eq, Clone, Copy, Serialize, Debug)]
+pub struct Animations {
+    pub boot: AnimBooting,
+    pub awake: AnimAwake,
+    pub sleep: AnimSleeping,
+    pub shutdown: AnimShutdown,
+}
 
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
-pub struct AnimePowerStates {
-    pub brightness: u8,
-    pub enabled: bool,
-    pub boot_anim_enabled: bool,
+pub struct DeviceState {
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
 }
 
 #[cfg_attr(feature = "dbus", derive(Type))]
@@ -41,14 +50,29 @@ pub struct AnimePowerStates {
 pub enum AnimeType {
     GA401,
     GA402,
+    GU604,
+    Unknown,
+}
+
+impl FromStr for AnimeType {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s {
+            "ga401" | "GA401" => Self::GA401,
+            "ga402" | "GA402" => Self::GA402,
+            "gu604" | "GU604" => Self::GU604,
+            _ => Self::Unknown,
+        })
+    }
 }
 
 impl AnimeType {
     /// The width of diagonal images
     pub fn width(&self) -> usize {
         match self {
-            AnimeType::GA401 => 74,
-            AnimeType::GA402 => 74,
+            AnimeType::GU604 => 70,
+            _ => 74,
         }
     }
 
@@ -56,7 +80,8 @@ impl AnimeType {
     pub fn height(&self) -> usize {
         match self {
             AnimeType::GA401 => 36,
-            AnimeType::GA402 => 39,
+            AnimeType::GU604 => 43,
+            _ => 39,
         }
     }
 
@@ -64,7 +89,8 @@ impl AnimeType {
     pub fn data_length(&self) -> usize {
         match self {
             AnimeType::GA401 => PANE_LEN * 2,
-            AnimeType::GA402 => PANE_LEN * 3,
+            AnimeType::GU604 => PANE_LEN * 3,
+            _ => PANE_LEN * 3,
         }
     }
 }
@@ -103,8 +129,8 @@ impl AnimeDataBuffer {
 
     /// Create from a vector of bytes
     ///
-    /// # Panics
-    /// Will panic if the vector length is not `ANIME_DATA_LEN`
+    /// # Errors
+    /// Will error if the vector length is not `ANIME_DATA_LEN`
     #[inline]
     pub fn from_vec(anime: AnimeType, data: Vec<u8>) -> Result<Self> {
         if data.len() != anime.data_length() {
@@ -115,7 +141,7 @@ impl AnimeDataBuffer {
     }
 }
 
-/// The two packets to be written to USB
+/// The packets to be written to USB
 pub type AnimePacketType = Vec<[u8; 640]>;
 
 impl TryFrom<AnimeDataBuffer> for AnimePacketType {
@@ -128,7 +154,7 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
 
         let mut buffers = match anime.anime {
             AnimeType::GA401 => vec![[0; 640]; 2],
-            AnimeType::GA402 => vec![[0; 640]; 3],
+            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unknown => vec![[0; 640]; 3],
         };
 
         for (idx, chunk) in anime.data.as_slice().chunks(PANE_LEN).enumerate() {
@@ -137,20 +163,22 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
         buffers[0][..7].copy_from_slice(&USB_PREFIX1);
         buffers[1][..7].copy_from_slice(&USB_PREFIX2);
 
-        if matches!(anime.anime, AnimeType::GA402) {
+        if matches!(
+            anime.anime,
+            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unknown
+        ) {
             buffers[2][..7].copy_from_slice(&USB_PREFIX3);
         }
         Ok(buffers)
     }
 }
 
-/// This runs the animations as a blocking loop by using the `callback` to write data
+/// This runs the animations as a blocking loop by using the `callback` to write
+/// data
 ///
-/// If `callback` is `Ok(true)` then `run_animation` will exit the animation loop early.
-pub fn run_animation(
-    frames: &AnimeGif,
-    callback: &dyn Fn(AnimeDataBuffer) -> Result<bool>,
-) -> Result<()> {
+/// If `callback` is `Ok(true)` then `run_animation` will exit the animation
+/// loop early.
+pub fn run_animation(frames: &AnimeGif, callback: &dyn Fn(AnimeDataBuffer) -> Result<bool>) {
     let mut count = 0;
     let start = Instant::now();
 
@@ -215,9 +243,10 @@ pub fn run_animation(
                 }
             }
 
+            // TODO: Log this error
             if matches!(callback(output), Ok(true)) {
-                info!("rog-anime: frame-loop callback asked to exit early");
-                return Ok(());
+                info!("rog-anime: animation frame-loop callback asked to exit early");
+                return;
             }
 
             if timed && Instant::now().duration_since(start) > run_time {
@@ -232,5 +261,4 @@ pub fn run_animation(
             }
         }
     }
-    Ok(())
 }

rog-anime/src/diagonal.rs

@@ -1,12 +1,14 @@
-use std::{path::Path, time::Duration};
+//! This is full of crap code which is basically bruteforced
 
-use crate::{
-    data::AnimeDataBuffer,
-    error::{AnimeError, Result},
-    AnimeType,
-};
+use std::path::Path;
+use std::time::Duration;
 
-/// Mostly intended to be used with ASUS gifs, but can be used for other purposes (like images)
+use crate::data::AnimeDataBuffer;
+use crate::error::{AnimeError, Result};
+use crate::AnimeType;
+
+/// Mostly intended to be used with ASUS gifs, but can be used for other
+/// purposes (like images)
 #[derive(Debug, Clone)]
 pub struct AnimeDiagonal(AnimeType, Vec<Vec<u8>>, Option<Duration>);
 
@@ -25,7 +27,8 @@ impl AnimeDiagonal {
         &mut self.1
     }
 
-    /// Get a full diagonal row where `x` `y` is the starting point  and `len` is the length of data.
+    /// Get a full diagonal row where `x` `y` is the starting point  and `len`
+    /// is the length of data.
     fn get_row(&self, x: usize, y: usize, len: usize) -> Vec<u8> {
         let mut buf = Vec::with_capacity(len);
         for i in 0..len {
@@ -36,8 +39,9 @@ impl AnimeDiagonal {
         buf
     }
 
-    /// Generate the base image from inputs. The result can be displayed as is or
-    /// updated via scale, position, or angle then displayed again after `update()`.
+    /// Generate the base image from inputs. The result can be displayed as is
+    /// or updated via scale, position, or angle then displayed again after
+    /// `update()`.
     #[inline]
     pub fn from_png(
         path: &Path,
@@ -52,39 +56,43 @@ impl AnimeDiagonal {
 
         let mut matrix = AnimeDiagonal::new(anime_type, duration);
 
-        match raster {
+        match &raster {
             png_pong::PngRaster::Gray8(ras) => {
-                Self::pixels_from_8bit(ras, &mut matrix, bright, true)
+                Self::pixels_from_8bit(ras, &mut matrix, bright, true);
             }
             png_pong::PngRaster::Graya8(ras) => {
-                Self::pixels_from_8bit(ras, &mut matrix, bright, true)
+                Self::pixels_from_8bit(ras, &mut matrix, bright, true);
             }
             png_pong::PngRaster::Rgb8(ras) => {
-                Self::pixels_from_8bit(ras, &mut matrix, bright, false)
+                Self::pixels_from_8bit(ras, &mut matrix, bright, false);
             }
             png_pong::PngRaster::Rgba8(ras) => {
-                Self::pixels_from_8bit(ras, &mut matrix, bright, false)
+                Self::pixels_from_8bit(ras, &mut matrix, bright, false);
             }
             png_pong::PngRaster::Gray16(ras) => {
-                Self::pixels_from_16bit(ras, &mut matrix, bright, true)
+                Self::pixels_from_16bit(ras, &mut matrix, bright, true);
             }
             png_pong::PngRaster::Rgb16(ras) => {
-                Self::pixels_from_16bit(ras, &mut matrix, bright, false)
+                Self::pixels_from_16bit(ras, &mut matrix, bright, false);
             }
             png_pong::PngRaster::Graya16(ras) => {
-                Self::pixels_from_16bit(ras, &mut matrix, bright, true)
+                Self::pixels_from_16bit(ras, &mut matrix, bright, true);
             }
             png_pong::PngRaster::Rgba16(ras) => {
-                Self::pixels_from_16bit(ras, &mut matrix, bright, false)
+                Self::pixels_from_16bit(ras, &mut matrix, bright, false);
             }
-            _ => return Err(AnimeError::Format),
+            png_pong::PngRaster::Palette(..) => return Err(AnimeError::Format),
         };
 
         Ok(matrix)
     }
 
-    fn pixels_from_8bit<P>(ras: pix::Raster<P>, matrix: &mut AnimeDiagonal, bright: f32, grey: bool)
-    where
+    fn pixels_from_8bit<P>(
+        ras: &pix::Raster<P>,
+        matrix: &mut AnimeDiagonal,
+        bright: f32,
+        grey: bool,
+    ) where
         P: pix::el::Pixel<Chan = pix::chan::Ch8>,
     {
         let width = ras.width();
@@ -105,7 +113,7 @@ impl AnimeDiagonal {
     }
 
     fn pixels_from_16bit<P>(
-        ras: pix::Raster<P>,
+        ras: &pix::Raster<P>,
         matrix: &mut AnimeDiagonal,
         bright: f32,
         grey: bool,
@@ -132,11 +140,12 @@ impl AnimeDiagonal {
     pub fn into_data_buffer(&self, anime_type: AnimeType) -> Result<AnimeDataBuffer> {
         match anime_type {
             AnimeType::GA401 => self.to_ga401_packets(),
-            AnimeType::GA402 => self.to_ga402_packets(),
+            AnimeType::GU604 => self.to_gu604_packets(),
+            _ => self.to_ga402_packets(),
         }
     }
 
-    /// Do conversion from the nested Vec in AnimeMatrix to the two required
+    /// Do conversion from the nested Vec in `AnimeMatrix` to the two required
     /// packets suitable for sending over USB
     fn to_ga401_packets(&self) -> Result<AnimeDataBuffer> {
         let mut buf = vec![0u8; AnimeType::GA401.data_length()];
@@ -282,387 +291,89 @@ impl AnimeDiagonal {
 
         AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use std::{convert::TryFrom, path::PathBuf};
+    fn to_gu604_packets(&self) -> Result<AnimeDataBuffer> {
+        let mut buf = vec![0u8; AnimeType::GU604.data_length()];
+        let mut start_index: usize = 0;
 
-    use crate::{AnimeDiagonal, AnimePacketType, AnimeType};
+        fn copy_slice(
+            buf: &mut [u8],
+            anime: &AnimeDiagonal,
+            x: usize,
+            y: usize,
+            start_index: &mut usize,
+            len: usize,
+        ) {
+            buf[*start_index..*start_index + len].copy_from_slice(&anime.get_row(x, y, len));
+            *start_index += len;
+        }
 
-    #[test]
-    fn ga401_diagonal_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
+        let b = &mut buf;
+        let a = &self;
+        copy_slice(b, a, 0, 4, &mut start_index, 38);
+        copy_slice(b, a, 0, 3, &mut start_index, 39);
+        copy_slice(b, a, 1, 3, &mut start_index, 38);
+        copy_slice(b, a, 1, 2, &mut start_index, 39);
+        copy_slice(b, a, 2, 2, &mut start_index, 38);
+        copy_slice(b, a, 2, 1, &mut start_index, 39);
+        copy_slice(b, a, 3, 1, &mut start_index, 38);
+        copy_slice(b, a, 3, 0, &mut start_index, 39);
+        copy_slice(b, a, 4, 0, &mut start_index, 39);
+        copy_slice(b, a, 5, 0, &mut start_index, 39);
+        copy_slice(b, a, 6, 0, &mut start_index, 38);
+        copy_slice(b, a, 7, 0, &mut start_index, 38);
+        copy_slice(b, a, 8, 0, &mut start_index, 37);
+        copy_slice(b, a, 9, 0, &mut start_index, 37);
+        copy_slice(b, a, 10, 0, &mut start_index, 36);
+        copy_slice(b, a, 11, 0, &mut start_index, 36);
+        copy_slice(b, a, 12, 0, &mut start_index, 35);
+        copy_slice(b, a, 13, 0, &mut start_index, 35);
+        copy_slice(b, a, 14, 0, &mut start_index, 34);
+        copy_slice(b, a, 15, 0, &mut start_index, 34);
+        copy_slice(b, a, 16, 0, &mut start_index, 33);
+        copy_slice(b, a, 17, 0, &mut start_index, 33);
+        copy_slice(b, a, 18, 0, &mut start_index, 32);
+        copy_slice(b, a, 19, 0, &mut start_index, 32);
+        copy_slice(b, a, 20, 0, &mut start_index, 31);
+        copy_slice(b, a, 21, 0, &mut start_index, 31);
+        copy_slice(b, a, 22, 0, &mut start_index, 30);
+        copy_slice(b, a, 23, 0, &mut start_index, 30);
+        copy_slice(b, a, 24, 0, &mut start_index, 29);
+        copy_slice(b, a, 25, 0, &mut start_index, 29);
+        copy_slice(b, a, 26, 0, &mut start_index, 28);
+        copy_slice(b, a, 27, 0, &mut start_index, 28);
+        copy_slice(b, a, 28, 0, &mut start_index, 27);
+        copy_slice(b, a, 29, 0, &mut start_index, 27);
+        copy_slice(b, a, 30, 0, &mut start_index, 26);
+        copy_slice(b, a, 31, 0, &mut start_index, 26);
+        copy_slice(b, a, 32, 0, &mut start_index, 25);
+        copy_slice(b, a, 33, 0, &mut start_index, 25);
+        copy_slice(b, a, 34, 0, &mut start_index, 24);
+        copy_slice(b, a, 35, 0, &mut start_index, 24);
+        copy_slice(b, a, 36, 0, &mut start_index, 23);
+        copy_slice(b, a, 37, 0, &mut start_index, 23);
+        copy_slice(b, a, 38, 0, &mut start_index, 22);
+        copy_slice(b, a, 39, 0, &mut start_index, 22);
+        copy_slice(b, a, 40, 0, &mut start_index, 21);
+        copy_slice(b, a, 41, 0, &mut start_index, 21);
+        copy_slice(b, a, 42, 0, &mut start_index, 20);
+        copy_slice(b, a, 43, 0, &mut start_index, 20);
+        copy_slice(b, a, 44, 0, &mut start_index, 19);
+        copy_slice(b, a, 45, 0, &mut start_index, 19);
+        copy_slice(b, a, 46, 0, &mut start_index, 18);
+        copy_slice(b, a, 47, 0, &mut start_index, 18);
+        copy_slice(b, a, 48, 0, &mut start_index, 17);
+        copy_slice(b, a, 49, 0, &mut start_index, 17);
+        copy_slice(b, a, 50, 0, &mut start_index, 16);
+        copy_slice(b, a, 51, 0, &mut start_index, 16);
+        copy_slice(b, a, 52, 0, &mut start_index, 15);
+        copy_slice(b, a, 53, 0, &mut start_index, 15);
+        copy_slice(b, a, 54, 0, &mut start_index, 14);
+        copy_slice(b, a, 55, 0, &mut start_index, 14);
+        copy_slice(b, a, 56, 0, &mut start_index, 13);
+        copy_slice(b, a, 57, 0, &mut start_index, 13);
+        copy_slice(b, a, 58, 0, &mut start_index, 12);
 
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga401-diagonal.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA401).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA401).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-    }
-
-    #[test]
-    fn ga402_diagonal_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga402-diagonal.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
-    }
-
-    #[test]
-    #[ignore = "Needs the packets verified with capture"]
-    fn ga402_diagonal_fullbright_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x68, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x67, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga402-diagonal-fullbright.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
     }
 }

rog-anime/src/error.rs

@@ -1,8 +1,9 @@
-use gif::DecodingError;
-use png_pong::decode::Error as PngError;
 use std::error::Error;
 use std::fmt;
 
+use gif::DecodingError;
+use png_pong::decode::Error as PngError;
+
 pub type Result<T> = std::result::Result<T, AnimeError>;
 
 #[derive(Debug)]
@@ -12,7 +13,8 @@ pub enum AnimeError {
     Png(PngError),
     Gif(DecodingError),
     Format,
-    /// The input was incorrect size, expected size is `IncorrectSize(width, height)`
+    /// The input was incorrect size, expected size is `IncorrectSize(width,
+    /// height)`
     IncorrectSize(u32, u32),
     Dbus(String),
     Udev(String, std::io::Error),
@@ -22,12 +24,14 @@ pub enum AnimeError {
     DataBufferLength,
     PixelGifWidth(usize),
     PixelGifHeight(usize),
+    ParseError(String),
 }
 
 impl fmt::Display for AnimeError {
     #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            AnimeError::ParseError(e) => write!(f, "Could not parse {e}"),
             AnimeError::NoFrames => write!(f, "No frames in PNG"),
             AnimeError::Io(e) => write!(f, "Could not open: {}", e),
             AnimeError::Png(e) => write!(f, "PNG error: {}", e),

rog-anime/src/gif.rs

@@ -1,15 +1,19 @@
+use std::convert::TryFrom;
+use std::fs::File;
+use std::path::Path;
+use std::time::Duration;
+
 use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::{fs::File, path::Path, time::Duration};
 
-use crate::error::AnimeError;
-use crate::{error::Result, AnimeDataBuffer, AnimeDiagonal, AnimeImage, AnimeType, Pixel};
+use crate::error::{AnimeError, Result};
+use crate::{AnimeDataBuffer, AnimeDiagonal, AnimeImage, AnimeType, Pixel};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AnimeFrame {
     /// Precomputed data for the frame. This can be transferred directly to the
-    /// the `asusd` daemon over dbus or converted to USB packet with `AnimePacketType::from(buffer)`
+    /// the `asusd` daemon over dbus or converted to USB packet with
+    /// `AnimePacketType::from(buffer)`
     data: AnimeDataBuffer,
     delay: Duration,
 }
@@ -33,7 +37,8 @@ impl AnimeFrame {
 pub enum AnimTime {
     /// Time in milliseconds for animation to run
     Time(Duration),
-    /// How many full animation loops to run or how many seconds if image is static
+    /// How many full animation loops to run or how many seconds if image is
+    /// static
     Count(u32),
     /// Run for infinite time
     Infinite,
@@ -105,13 +110,12 @@ impl AnimeGif {
         let file = File::open(file_name)?;
         let mut decoder = decoder.read_info(file)?;
 
-        let mut frames = Vec::with_capacity(decoder.buffer_size());
-
+        let mut frames = Vec::default();
         while let Some(frame) = decoder.read_next_frame()? {
             let wait = frame.delay * 10;
-            if matches!(frame.dispose, gif::DisposalMethod::Background) {
-                frames = Vec::new();
-            }
+            // if matches!(frame.dispose, gif::DisposalMethod::Background) {
+            //     frames = Vec::new();
+            // }
             for (y, row) in frame.buffer.chunks(frame.width as usize * 4).enumerate() {
                 for (x, px) in row.chunks(4).enumerate() {
                     if px[3] != 255 {
@@ -169,8 +173,8 @@ impl AnimeGif {
         Ok(Self(frames, duration))
     }
 
-    /// Create an animation using a gif of any size. This method must precompute the
-    /// result.
+    /// Create an animation using a gif of any size. This method must precompute
+    /// the result.
     #[inline]
     pub fn from_gif(
         file_name: &Path,
@@ -243,9 +247,10 @@ impl AnimeGif {
         Ok(Self(frames, duration))
     }
 
-    /// Make a static gif out of a greyscale png. If no duration is specified then the default
-    /// will be 1 second long. If `AnimTime::Cycles` is specified for `duration` then this can
-    /// be considered how many seconds the image will show for.
+    /// Make a static gif out of a greyscale png. If no duration is specified
+    /// then the default will be 1 second long. If `AnimTime::Cycles` is
+    /// specified for `duration` then this can be considered how many
+    /// seconds the image will show for.
     #[inline]
     pub fn from_png(
         file_name: &Path,

rog-anime/src/grid.rs

@@ -93,7 +93,7 @@ impl AnimeGrid {
 impl TryFrom<AnimeGrid> for AnimeDataBuffer {
     type Error = AnimeError;
 
-    /// Do conversion from the nested Vec in AniMeMatrix to the two required
+    /// Do conversion from the nested Vec in anime matrix to the two required
     /// packets suitable for sending over USB
     fn try_from(anime: AnimeGrid) -> Result<Self> {
         let mut buf = vec![0u8; anime.anime_type.data_length()];

rog-anime/src/image.rs

@@ -1,17 +1,16 @@
-use std::{convert::TryFrom, path::Path};
+use std::convert::TryFrom;
+use std::path::Path;
 
 pub use glam::Vec2;
 use glam::{Mat3, Vec3};
 
-use crate::{
-    data::AnimeDataBuffer,
-    error::{AnimeError, Result},
-    AnimeType,
-};
+use crate::data::AnimeDataBuffer;
+use crate::error::{AnimeError, Result};
+use crate::AnimeType;
 
 /// A single greyscale + alpha pixel in the image
 #[derive(Copy, Clone, Debug)]
-pub(crate) struct Pixel {
+pub struct Pixel {
     pub color: u32,
     pub alpha: f32,
 }
@@ -29,8 +28,8 @@ impl Default for Pixel {
 /// A single LED position and brightness. The intention of this struct
 /// is to be used to sample an image and set the LED brightness.
 ///
-/// The position of the Led in `LedPositions` determines the placement in the final
-/// data packets when written to the AniMe.
+/// The position of the Led in `LedPositions` determines the placement in the
+/// final data packets when written to the `AniMe`.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Led(f32, f32, u8);
 
@@ -58,7 +57,7 @@ impl Led {
 
 /// Container of `Led`, each of which specifies a position within the image
 /// The main use of this is to position and sample colours for the final image
-/// to show on AniMe
+/// to show on `AniMe`
 pub struct AnimeImage {
     pub scale: Vec2,
     /// Angle in radians
@@ -73,13 +72,15 @@ pub struct AnimeImage {
     img_pixels: Vec<Pixel>,
     /// width of the image
     width: u32,
-    /// The type of the display. The GA401 and GA402 use the same controller and therefore same ID,
-    /// so the identifier must be by laptop model in `AnimeType`.
+    /// The type of the display. The GA401 and GA402 use the same controller and
+    /// therefore same ID, so the identifier must be by laptop model in
+    /// `AnimeType`.
     anime_type: AnimeType,
 }
 
 impl AnimeImage {
-    pub(crate) fn new(
+    /// Exposed only for tests. Please use `from_png()` instead.
+    pub fn new(
         scale: Vec2,
         angle: f32,
         translation: Vec2,
@@ -108,39 +109,45 @@ impl AnimeImage {
 
     /// Scale ratio in CM
     ///
-    /// This is worked out by measuring the physical width of the display from pixel center to
-    /// center, then dividing by `<horizontal LED count> + 0.5`, where the LED count is
-    /// first/longest row.
+    /// This is worked out by measuring the physical width of the display from
+    /// pixel center to center, then dividing by `<horizontal LED count> +
+    /// 0.5`, where the LED count is first/longest row.
     ///
     /// For GA401 this is `26.8 / (33 + 0.5) = 0.8`
     /// For GA402 this is `27.4 / (35 + 0.5) = 0.77`
+    /// For GA402 this is `30.9 / (39 + 0.5) = 0.77`
     fn scale_x(anime_type: AnimeType) -> f32 {
         match anime_type {
             AnimeType::GA401 => 0.8,
-            AnimeType::GA402 => 0.77,
+            AnimeType::GU604 => 0.78,
+            _ => 0.77,
         }
     }
 
     /// Scale ratio in CM
     ///
-    /// This is worked out by measuring the physical height of the display from pixel center to
-    /// pixel center, then dividing by  `<vertical LED count> + 1.0`, where the LED count is
-    /// first/longest row.
+    /// This is worked out by measuring the physical height of the display from
+    /// pixel center to pixel center, then dividing by 10 divided  `<vertical
+    /// LED count> + 1.0`, where the LED count is first/longest row.
     ///
     /// For GA401 this is `16.5 / (54.0 + 1.0) = 0.3`
     /// For GA402 this is `17.3 / (61.0)       = 0.283`
+    /// For GU604 this is `17.7 / (62.0 + 1)   = 0.28`
     fn scale_y(anime_type: AnimeType) -> f32 {
         match anime_type {
             AnimeType::GA401 => 0.3,
-            AnimeType::GA402 => 0.283,
+            AnimeType::GU604 => 0.28,
+            _ => 0.283,
         }
     }
 
-    /// Get the starting X position for the data we actually require when writing
-    /// it out to LEDs.
+    /// Get the starting X position for the data we actually require when
+    /// writing it out to LEDs.
+    ///
+    /// In relation to the display itself you should think of it as a full
+    /// square grid, so `first_x` is the x position on that grid where the
+    /// LED is actually positioned in relation to the Y.
     ///
-    /// In relation to the display itself you should think of it as a full square grid, so `first_x`
-    /// is the x position on that grid where the LED is actually positioned in relation to the Y.
     /// ```text
     /// +------------+
     /// |            |
@@ -163,7 +170,15 @@ impl AnimeImage {
                 }
                 (y + 1) / 2 - 3
             }
-            AnimeType::GA402 => {
+            AnimeType::GU604 => {
+                // first 9 rows start at zero
+                if y <= 9 {
+                    return 0;
+                }
+                // and then their offset grows by one every two rows
+                (y - 9) / 2
+            }
+            _ => {
                 // first 11 rows start at zero
                 if y <= 11 {
                     return 0;
@@ -189,6 +204,7 @@ impl AnimeImage {
     ///       \      |
     ///        ------+
     /// ```
+    // TODO: make this return only width, and move calcs to pitch
     fn width(anime_type: AnimeType, y: u32) -> u32 {
         match anime_type {
             AnimeType::GA401 => {
@@ -198,7 +214,13 @@ impl AnimeImage {
                 }
                 36 - (y + 1) / 2
             }
-            AnimeType::GA402 => {
+            AnimeType::GU604 => {
+                if y <= 9 {
+                    return 38 + y % 2;
+                }
+                38 - Self::first_x(anime_type, y) + y % 2
+            }
+            _ => {
                 if y <= 11 {
                     return 34;
                 }
@@ -212,7 +234,9 @@ impl AnimeImage {
         match anime_type {
             // 33.0 = Longest row LED count (physical) plus half-pixel offset
             AnimeType::GA401 => (33.0 + 0.5) * Self::scale_x(anime_type),
-            AnimeType::GA402 => (35.0 + 0.5) * Self::scale_x(anime_type),
+
+            AnimeType::GU604 => (38.0 + 0.5) * Self::scale_x(anime_type),
+            _ => (35.0 + 0.5) * Self::scale_x(anime_type),
         }
     }
 
@@ -220,7 +244,8 @@ impl AnimeImage {
     fn height(anime_type: AnimeType) -> u32 {
         match anime_type {
             AnimeType::GA401 => 55,
-            AnimeType::GA402 => 61,
+            AnimeType::GU604 => 62,
+            _ => 61,
         }
     }
 
@@ -229,8 +254,9 @@ impl AnimeImage {
         match anime_type {
             // 54.0 = End column LED count (physical) plus one dead pixel
             AnimeType::GA401 => (54.0 + 1.0) * Self::scale_y(anime_type),
+            AnimeType::GU604 => 62.0 * Self::scale_y(anime_type),
             // GA402 may not have dead pixels and require only the physical LED count
-            AnimeType::GA402 => 61.0 * Self::scale_y(anime_type),
+            _ => 61.0 * Self::scale_y(anime_type),
         }
     }
 
@@ -242,8 +268,9 @@ impl AnimeImage {
                 1 | 3 => 35, // Some rows are padded
                 _ => 36 - y / 2,
             },
+            AnimeType::GU604 => AnimeImage::width(anime_type, y),
             // GA402 does not have padding, equivalent to width
-            AnimeType::GA402 => AnimeImage::width(anime_type, y),
+            _ => AnimeImage::width(anime_type, y),
         }
     }
 
@@ -251,8 +278,8 @@ impl AnimeImage {
         &mut self.img_pixels
     }
 
-    /// Generate a list of LED positions. These are then used to sample the Image data,
-    /// and will contain their resulting brightness.
+    /// Generate a list of LED positions. These are then used to sample the
+    /// Image data, and will contain their resulting brightness.
     #[inline]
     pub fn generate_image_positioning(anime_type: AnimeType) -> Vec<Option<Led>> {
         (0..AnimeImage::height(anime_type))
@@ -274,8 +301,8 @@ impl AnimeImage {
     /// samples, the result can then been transformed to the appropriate data
     /// for displaying.
     ///
-    /// The internal for loop iterates over the LED positions, skipping the blank/dead
-    /// pixels if any.
+    /// The internal for loop iterates over the LED positions, skipping the
+    /// blank/dead pixels if any.
     #[inline]
     pub fn update(&mut self) {
         let width = self.width as i32;
@@ -294,8 +321,8 @@ impl AnimeImage {
             let x0 = led_from_px.mul_vec3(pos + Vec3::new(0.0, -0.5, 0.0));
 
             const GROUP: [f32; 4] = [0.0, 0.5, 1.0, 1.5];
-            for u in GROUP.iter() {
-                for v in GROUP.iter() {
+            for u in &GROUP {
+                for v in &GROUP {
                     let sample = x0 + *u * du + *v * dv;
 
                     let x = sample.x as i32;
@@ -317,7 +344,7 @@ impl AnimeImage {
     }
 
     /// A helper for determining physical position alignment
-    fn _edge_outline(&mut self) {
+    pub fn edge_outline(&mut self) {
         // Janky shit here just to try help align images
         let mut last_x = 0.0;
         let mut last_y = 0.0;
@@ -343,7 +370,7 @@ impl AnimeImage {
                 }
                 last_was_led = true;
             } else if last_was_led {
-                //ends.push(idx);
+                // ends.push(idx);
                 last_was_led = false;
             }
         }
@@ -382,8 +409,9 @@ impl AnimeImage {
         led_from_px.inverse()
     }
 
-    /// Generate the base image from inputs. The result can be displayed as is or
-    /// updated via scale, position, or angle then displayed again after `update()`.
+    /// Generate the base image from inputs. The result can be displayed as is
+    /// or updated via scale, position, or angle then displayed again after
+    /// `update()`.
     #[inline]
     pub fn from_png(
         path: &Path,
@@ -399,7 +427,7 @@ impl AnimeImage {
         let png_pong::Step { raster, delay: _ } = decoder.last().ok_or(AnimeError::NoFrames)??;
 
         let width;
-        let pixels = match raster {
+        let pixels = match &raster {
             png_pong::PngRaster::Gray8(ras) => {
                 width = ras.width();
                 Self::pixels_from_8bit(ras, true)
@@ -432,7 +460,7 @@ impl AnimeImage {
                 width = ras.width();
                 Self::pixels_from_16bit(ras, false)
             }
-            _ => return Err(AnimeError::Format),
+            png_pong::PngRaster::Palette(..) => return Err(AnimeError::Format),
         };
 
         let mut matrix = AnimeImage::new(
@@ -449,7 +477,7 @@ impl AnimeImage {
         Ok(matrix)
     }
 
-    fn pixels_from_8bit<P>(ras: pix::Raster<P>, grey: bool) -> Vec<Pixel>
+    fn pixels_from_8bit<P>(ras: &pix::Raster<P>, grey: bool) -> Vec<Pixel>
     where
         P: pix::el::Pixel<Chan = pix::chan::Ch8>,
     {
@@ -468,7 +496,7 @@ impl AnimeImage {
             .collect()
     }
 
-    fn pixels_from_16bit<P>(ras: pix::Raster<P>, grey: bool) -> Vec<Pixel>
+    fn pixels_from_16bit<P>(ras: &pix::Raster<P>, grey: bool) -> Vec<Pixel>
     where
         P: pix::el::Pixel<Chan = pix::chan::Ch16>,
     {
@@ -491,8 +519,8 @@ impl AnimeImage {
 impl TryFrom<&AnimeImage> for AnimeDataBuffer {
     type Error = AnimeError;
 
-    /// Do conversion from the nested Vec in AnimeDataBuffer to the two required
-    /// packets suitable for sending over USB
+    /// Do conversion from the nested Vec in `AnimeDataBuffer` to the two
+    /// required packets suitable for sending over USB
     fn try_from(leds: &AnimeImage) -> Result<Self> {
         let mut l: Vec<u8> = leds
             .led_pos
@@ -511,9 +539,11 @@ impl TryFrom<&AnimeImage> for AnimeDataBuffer {
 
 #[cfg(test)]
 mod tests {
-    use std::{convert::TryFrom, path::PathBuf};
+    use std::convert::TryFrom;
+    use std::path::PathBuf;
 
-    use crate::{image::*, AnimTime, AnimeGif, AnimePacketType};
+    use crate::image::*;
+    use crate::{AnimTime, AnimeGif, AnimePacketType};
 
     #[test]
     fn led_positions() {
@@ -604,149 +634,6 @@ mod tests {
         assert_eq!(AnimeImage::pitch(a, 14), 29);
     }
 
-    #[test]
-    fn ga402_image_edge_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut matrix = AnimeImage::new(
-            Vec2::new(1.0, 1.0),
-            0.0,
-            Vec2::default(),
-            0.0,
-            vec![Pixel::default(); 1000],
-            100,
-            AnimeType::GA402,
-        )
-        .unwrap();
-        matrix._edge_outline();
-        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
-    }
-
     #[test]
     #[ignore = "Just to inspect image packet"]
     fn ga402_image_packet_check() {

rog-anime/src/lib.rs

@@ -7,12 +7,12 @@ pub use data::*;
 mod grid;
 pub use grid::*;
 
-/// Transform a PNG image for displaying on AniMe matrix display
+/// Transform a PNG image for displaying on `AniMe` matrix display
 mod image;
 pub use image::*;
 
-/// A grid of data that is intended to be read out and displayed on the ANiMe as
-/// a diagonal
+/// A grid of data that is intended to be read out and displayed on the `AniMe`
+/// as a diagonal
 mod diagonal;
 pub use diagonal::*;
 
@@ -21,8 +21,8 @@ pub use diagonal::*;
 mod gif;
 pub use crate::gif::*;
 
-/// A container of images/grids/gifs/pauses which can be iterated over to generate
-/// cool effects
+/// A container of images/grids/gifs/pauses which can be iterated over to
+/// generate cool effects
 mod sequencer;
 pub use sequencer::*;
 

rog-anime/src/sequencer.rs

@@ -1,14 +1,15 @@
+use std::convert::TryFrom;
+use std::path::PathBuf;
+use std::time::Duration;
+
 use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::{path::PathBuf, time::Duration};
 
-use crate::{
-    error::Result, AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType,
-};
+use crate::error::Result;
+use crate::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType};
 
-/// All the possible AniMe actions that can be used. This enum is intended to be
-/// a helper for loading up `ActionData`.
+/// All the possible `AniMe` actions that can be used. This enum is intended to
+/// be a helper for loading up `ActionData`.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum ActionLoader {
     /// Full gif sequence. Immutable.
@@ -23,7 +24,8 @@ pub enum ActionLoader {
         time: AnimTime,
         brightness: f32,
     },
-    /// Animated gif. If the file is a png a static gif is created using the `time` properties
+    /// Animated gif. If the file is a png a static gif is created using the
+    /// `time` properties
     ImageAnimation {
         file: PathBuf,
         scale: f32,
@@ -44,13 +46,14 @@ pub enum ActionLoader {
     Pause(Duration),
 }
 
-/// All the possible AniMe actions that can be used. The enum is intended to be
-/// used in a array allowing the user to cycle through a series of actions.
+/// All the possible `AniMe` actions that can be used. The enum is intended to
+/// be used in a array allowing the user to cycle through a series of actions.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum ActionData {
     /// Full gif sequence. Immutable.
     Animation(AnimeGif),
-    /// Basic image, can have properties changed and image updated via those properties
+    /// Basic image, can have properties changed and image updated via those
+    /// properties
     Image(Box<AnimeDataBuffer>),
     /// A pause to be used between sequences
     Pause(Duration),
@@ -174,8 +177,8 @@ impl Sequences {
         Self(Vec::new(), anime_type)
     }
 
-    /// Use a base `AnimeAction` to generate the precomputed data and insert in to
-    /// the run buffer
+    /// Use a base `AnimeAction` to generate the precomputed data and insert in
+    /// to the run buffer
     #[inline]
     pub fn insert(&mut self, index: usize, action: &ActionLoader) -> Result<()> {
         self.0
@@ -183,9 +186,9 @@ impl Sequences {
         Ok(())
     }
 
-    /// Remove an item at this position from the run buffer. If the `index` supplied
-    /// is not in range then `None` is returned, otherwise the `ActionData` at that location
-    /// is yeeted and returned.
+    /// Remove an item at this position from the run buffer. If the `index`
+    /// supplied is not in range then `None` is returned, otherwise the
+    /// `ActionData` at that location is yeeted and returned.
     #[inline]
     pub fn remove_item(&mut self, index: usize) -> Option<ActionData> {
         if index < self.0.len() {
@@ -194,7 +197,7 @@ impl Sequences {
         None
     }
 
-    pub fn iter(&self) -> ActionIterator {
+    pub fn iter(&self) -> ActionIterator<'_> {
         ActionIterator {
             actions: self,
             next_idx: 0,

rog-anime/src/usb.rs

@@ -1,24 +1,146 @@
-//! Utils for writing to the AniMe USB device
+//! Utils for writing to the `AniMe` USB device
 //!
 //! Use of the device requires a few steps:
-//! 1. Initialise the device by writing the two packets from `get_init_packets()`
-//! 2. Write data from `AnimePacketType`
-//! 3. Write the packet from `get_flush_packet()`, which tells the device to display the data from step 2
+//! 1. Initialise the device by writing the two packets from
+//! `get_init_packets()` 2. Write data from `AnimePacketType`
+//! 3. Write the packet from `get_flush_packet()`, which tells the device to
+//! display the data from step 2
 //!
 //! Step 1 need to applied only on fresh system boot.
 
-use crate::{error::AnimeError, AnimeType};
+use std::str::FromStr;
+
+use serde_derive::{Deserialize, Serialize};
+#[cfg(feature = "dbus")]
+use zbus::zvariant::Type;
+
+use crate::error::AnimeError;
+use crate::AnimeType;
 
-const INIT_STR: [u8; 15] = [
-    0x5e, b'A', b'S', b'U', b'S', b' ', b'T', b'e', b'c', b'h', b'.', b'I', b'n', b'c', b'.',
-];
 const PACKET_SIZE: usize = 640;
 const DEV_PAGE: u8 = 0x5e;
 pub const VENDOR_ID: u16 = 0x0b05;
 pub const PROD_ID: u16 = 0x193b;
 
-/// `get_anime_type` is very broad, matching on part of the laptop board name only. For this
-/// reason `find_node()` must be used also to verify if the USB device is available.
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+/// Base LED brightness of the display
+pub enum Brightness {
+    Off,
+    Low,
+    #[default]
+    Med,
+    High,
+}
+
+impl FromStr for Brightness {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "Off" | "off" => Brightness::Off,
+            "Low" | "low" => Brightness::Low,
+            "Med" | "med" => Brightness::Med,
+            "High" | "high" => Brightness::High,
+            _ => Brightness::Med,
+        })
+    }
+}
+
+impl From<u8> for Brightness {
+    fn from(v: u8) -> Brightness {
+        match v {
+            0 => Brightness::Off,
+            2 => Brightness::Low,
+            3 => Brightness::High,
+            _ => Brightness::Med,
+        }
+    }
+}
+
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+pub enum AnimBooting {
+    #[default]
+    GlitchConstruction,
+    StaticEmergence,
+}
+
+impl FromStr for AnimBooting {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "GlitchConstruction" => Ok(Self::GlitchConstruction),
+            "StaticEmergence" => Ok(Self::StaticEmergence),
+            _ => Err(AnimeError::ParseError(s.to_owned())),
+        }
+    }
+}
+
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+pub enum AnimAwake {
+    #[default]
+    BinaryBannerScroll,
+    RogLogoGlitch,
+}
+
+impl FromStr for AnimAwake {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "BinaryBannerScroll" => Ok(Self::BinaryBannerScroll),
+            "RogLogoGlitch" => Ok(Self::RogLogoGlitch),
+            _ => Err(AnimeError::ParseError(s.to_owned())),
+        }
+    }
+}
+
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+pub enum AnimSleeping {
+    #[default]
+    BannerSwipe,
+    Starfield,
+}
+
+impl FromStr for AnimSleeping {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "BannerSwipe" => Ok(Self::BannerSwipe),
+            "Starfield" => Ok(Self::Starfield),
+            _ => Err(AnimeError::ParseError(s.to_owned())),
+        }
+    }
+}
+
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+pub enum AnimShutdown {
+    #[default]
+    GlitchOut,
+    SeeYa,
+}
+
+impl FromStr for AnimShutdown {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "GlitchOut" => Ok(Self::GlitchOut),
+            "SeeYa" => Ok(Self::SeeYa),
+            _ => Err(AnimeError::ParseError(s.to_owned())),
+        }
+    }
+}
+
+/// `get_anime_type` is very broad, matching on part of the laptop board name
+/// only. For this reason `find_node()` must be used also to verify if the USB
+/// device is available.
 ///
 /// The currently known USB device is `19b6`.
 #[inline]
@@ -30,23 +152,28 @@ pub fn get_anime_type() -> Result<AnimeType, AnimeError> {
         return Ok(AnimeType::GA401);
     } else if board_name.contains("GA402R") {
         return Ok(AnimeType::GA402);
+    } else if board_name.contains("GU604V") {
+        return Ok(AnimeType::GU604);
     }
-    Err(AnimeError::UnsupportedDevice)
+    log::warn!("AniMe Matrix device found but not yet supported, will default to a GA402 layout");
+    Ok(AnimeType::Unknown)
 }
 
-/// Get the two device initialization packets. These are required for device start
-/// after the laptop boots.
+/// Get the two device initialization packets. These are required for device
+/// start after the laptop boots.
 #[inline]
 pub const fn pkts_for_init() -> [[u8; PACKET_SIZE]; 2] {
     let mut packets = [[0; PACKET_SIZE]; 2];
     packets[0][0] = DEV_PAGE; // This is the USB page we're using throughout
     let mut count = 0;
-    while count < INIT_STR.len() {
-        packets[0][count] = INIT_STR[count];
+    // TODO: memcpy or slice copy
+    let bytes = "ASUS Tech.Inc.".as_bytes();
+    while count < bytes.len() {
+        packets[0][count + 1] = bytes[count];
         count += 1;
     }
     //
-    packets[1][0] = DEV_PAGE; // write it to be sure?
+    packets[1][0] = DEV_PAGE;
     packets[1][1] = 0xc2;
     packets
 }
@@ -54,7 +181,7 @@ pub const fn pkts_for_init() -> [[u8; PACKET_SIZE]; 2] {
 /// Should be written to the device after writing the two main data packets that
 /// make up the display data packet
 #[inline]
-pub const fn pkt_for_flush() -> [u8; PACKET_SIZE] {
+pub const fn pkt_flush() -> [u8; PACKET_SIZE] {
     let mut pkt = [0; PACKET_SIZE];
     pkt[0] = DEV_PAGE;
     pkt[1] = 0xc0;
@@ -62,10 +189,21 @@ pub const fn pkt_for_flush() -> [u8; PACKET_SIZE] {
     pkt
 }
 
-/// Get the packet required for setting the device to on, on boot. Requires
-/// pkt_for_apply()` to be written after.
+/// Packet for setting the brightness (0-3). Requires
+/// `pkt_for_apply()` to be written after.
 #[inline]
-pub const fn pkt_for_set_boot(status: bool) -> [u8; PACKET_SIZE] {
+pub const fn pkt_set_brightness(brightness: Brightness) -> [u8; PACKET_SIZE] {
+    let mut pkt = [0; PACKET_SIZE];
+    pkt[0] = DEV_PAGE;
+    pkt[1] = 0xc0;
+    pkt[2] = 0x04;
+    pkt[3] = brightness as u8;
+    pkt
+}
+
+/// Enable the display?
+#[inline]
+pub const fn pkt_set_enable_display(status: bool) -> [u8; PACKET_SIZE] {
     let mut pkt = [0; PACKET_SIZE];
     pkt[0] = DEV_PAGE;
     pkt[1] = 0xc3;
@@ -74,25 +212,31 @@ pub const fn pkt_for_set_boot(status: bool) -> [u8; PACKET_SIZE] {
     pkt
 }
 
-/// Get the packet required for setting the device to on. Requires `pkt_for_apply()`
-/// to be written after.
+/// Enable builtin animations?
 #[inline]
-pub const fn pkt_for_set_on(on: bool) -> [u8; PACKET_SIZE] {
-    let mut pkt = [0; PACKET_SIZE];
-    pkt[0] = DEV_PAGE;
-    pkt[1] = 0xc0;
-    pkt[2] = 0x04;
-    pkt[3] = if on { 0x03 } else { 0x00 };
-    pkt
-}
-
-/// Packet required to apply a device setting
-#[inline]
-pub const fn pkt_for_apply() -> [u8; PACKET_SIZE] {
+pub const fn pkt_set_enable_powersave_anim(status: bool) -> [u8; PACKET_SIZE] {
     let mut pkt = [0; PACKET_SIZE];
     pkt[0] = DEV_PAGE;
     pkt[1] = 0xc4;
     pkt[2] = 0x01;
-    pkt[3] = 0x80;
+    pkt[3] = if status { 0x00 } else { 0x80 };
+    pkt
+}
+
+/// Set which animations are shown for each stage
+#[inline]
+pub const fn pkt_set_builtin_animations(
+    boot: AnimBooting,
+    awake: AnimAwake,
+    sleep: AnimSleeping,
+    shutdown: AnimShutdown,
+) -> [u8; PACKET_SIZE] {
+    let mut pkt = [0; PACKET_SIZE];
+    pkt[0] = DEV_PAGE;
+    pkt[1] = 0xc5;
+    pkt[2] = (awake as u8)
+        | ((sleep as u8) << 0x01)
+        | ((shutdown as u8) << 0x02)
+        | ((boot as u8) << 0x03);
     pkt
 }

rog-anime/tests/ga401.rs

@@ -0,0 +1,239 @@
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use rog_anime::*;
+
+    #[test]
+    fn ga401_image_edge_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut matrix = AnimeImage::new(
+            Vec2::new(1.0, 1.0),
+            0.0,
+            Vec2::default(),
+            0.0,
+            vec![Pixel::default(); 1000],
+            100,
+            AnimeType::GA401,
+        )
+        .unwrap();
+        matrix.edge_outline();
+        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        // print!("left: '[");
+        // for b in pkt[1] {
+        //     print!("{b:#02x},");
+        // }
+        // print!("]'");
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+
+    #[test]
+    fn ga401_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x1, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("tests/data/ga401-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA401).unwrap();
+        let data = matrix.into_data_buffer(AnimeType::GA401).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+}

rog-anime/tests/ga402q.rs

@@ -0,0 +1,491 @@
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use rog_anime::*;
+
+    #[test]
+    fn ga402_image_edge_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x00, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut matrix = AnimeImage::new(
+            Vec2::new(1.0, 1.0),
+            0.0,
+            Vec2::default(),
+            0.0,
+            vec![Pixel::default(); 1000],
+            100,
+            AnimeType::GA402,
+        )
+        .unwrap();
+        matrix.edge_outline();
+        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
+    }
+
+    #[test]
+    fn ga402_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x1, 0x00, 0x73, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("tests/data/ga402-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(AnimeType::GA402).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
+    }
+
+    #[test]
+    #[ignore = "Needs the packets verified with capture"]
+    fn ga402_diagonal_fullbright_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x1, 0x00, 0x73, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x67, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("tests/data/ga402-diagonal-fullbright.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(AnimeType::GA402).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
+    }
+}