`5bc1809`

Complete phase 2-4 deferred targets: video, WebP, APNG, S3, PID, signals, cache

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 5bc1809c6a08819977ac0b4c934b0668c5fda1c3
Parents: 66c5f6e
Tree: b81801a

21 changed files

Status	File	+	-
M	`Cargo.lock`	1346	36
M	`Cargo.toml`	10	0
A	`DEFERRED.md`	101	0
M	`garbg/Cargo.toml`	18	5
M	`garbg/src/cache/disk.rs`	1	1
M	`garbg/src/config/types.rs`	0	1
M	`garbg/src/daemon/mod.rs`	2	0
A	`garbg/src/daemon/pid.rs`	136	0
M	`garbg/src/daemon/state.rs`	362	57
M	`garbg/src/ipc/gar_client.rs`	80	14
M	`garbg/src/ipc/server.rs`	0	1
M	`garbg/src/main.rs`	49	6
A	`garbg/src/media/apng.rs`	196	0
A	`garbg/src/media/frame_buffer.rs`	276	0
M	`garbg/src/media/loader.rs`	1	1
M	`garbg/src/media/mod.rs`	12	0
A	`garbg/src/media/video.rs`	311	0
A	`garbg/src/media/webp.rs`	193	0
M	`garbg/src/sources/mod.rs`	7	1
M	`garbg/src/sources/provider.rs`	42	2
A	`garbg/src/sources/s3.rs`	222	0

Cargo.lockmodified

1901 lines changed — click to load

  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 +[[package]]
 +name = "aws-config"
 +version = "1.8.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "96571e6996817bf3d58f6b569e4b9fd2e9d2fcf9f7424eed07b2ce9bb87535e5"
 +dependencies = [
 + "aws-credential-types",
 + "aws-runtime",
 + "aws-sdk-sso",
 + "aws-sdk-ssooidc",
 + "aws-sdk-sts",
 + "aws-smithy-async",
 + "aws-smithy-http",
 + "aws-smithy-json",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-types",
 + "bytes",
 + "fastrand",
 + "hex",
 + "http 1.4.0",
 + "ring",
 + "time",
 + "tokio",
 + "tracing",
 + "url",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "aws-credential-types"
 +version = "1.2.11"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3cd362783681b15d136480ad555a099e82ecd8e2d10a841e14dfd0078d67fee3"
 +dependencies = [
 + "aws-smithy-async",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "aws-lc-rs"
 +version = "1.15.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6a88aab2464f1f25453baa7a07c84c5b7684e274054ba06817f382357f77a288"
 +dependencies = [
 + "aws-lc-sys",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "aws-lc-sys"
 +version = "0.35.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "b45afffdee1e7c9126814751f88dddc747f41d91da16c9551a0f1e8a11e788a1"
 +dependencies = [
 + "cc",
 + "cmake",
 + "dunce",
 + "fs_extra",
 +]
++
 +[[package]]
 +name = "aws-runtime"
 +version = "1.5.17"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d81b5b2898f6798ad58f484856768bca817e3cd9de0974c24ae0f1113fe88f1b"
 +dependencies = [
 + "aws-credential-types",
 + "aws-sigv4",
 + "aws-smithy-async",
 + "aws-smithy-eventstream",
 + "aws-smithy-http",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-types",
 + "bytes",
 + "fastrand",
 + "http 0.2.12",
 + "http-body 0.4.6",
 + "percent-encoding",
 + "pin-project-lite",
 + "tracing",
 + "uuid",
 +]
++
 +[[package]]
 +name = "aws-sdk-s3"
 +version = "1.119.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1d65fddc3844f902dfe1864acb8494db5f9342015ee3ab7890270d36fbd2e01c"
 +dependencies = [
 + "aws-credential-types",
 + "aws-runtime",
 + "aws-sigv4",
 + "aws-smithy-async",
 + "aws-smithy-checksums",
 + "aws-smithy-eventstream",
 + "aws-smithy-http",
 + "aws-smithy-json",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-smithy-xml",
 + "aws-types",
 + "bytes",
 + "fastrand",
 + "hex",
 + "hmac",
 + "http 0.2.12",
 + "http 1.4.0",
 + "http-body 0.4.6",
 + "lru",
 + "percent-encoding",
 + "regex-lite",
 + "sha2",
 + "tracing",
 + "url",
 +]
++
 +[[package]]
 +name = "aws-sdk-sso"
 +version = "1.91.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "8ee6402a36f27b52fe67661c6732d684b2635152b676aa2babbfb5204f99115d"
 +dependencies = [
 + "aws-credential-types",
 + "aws-runtime",
 + "aws-smithy-async",
 + "aws-smithy-http",
 + "aws-smithy-json",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-types",
 + "bytes",
 + "fastrand",
 + "http 0.2.12",
 + "regex-lite",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-sdk-ssooidc"
 +version = "1.93.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "a45a7f750bbd170ee3677671ad782d90b894548f4e4ae168302c57ec9de5cb3e"
 +dependencies = [
 + "aws-credential-types",
 + "aws-runtime",
 + "aws-smithy-async",
 + "aws-smithy-http",
 + "aws-smithy-json",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-types",
 + "bytes",
 + "fastrand",
 + "http 0.2.12",
 + "regex-lite",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-sdk-sts"
 +version = "1.95.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "55542378e419558e6b1f398ca70adb0b2088077e79ad9f14eb09441f2f7b2164"
 +dependencies = [
 + "aws-credential-types",
 + "aws-runtime",
 + "aws-smithy-async",
 + "aws-smithy-http",
 + "aws-smithy-json",
 + "aws-smithy-query",
 + "aws-smithy-runtime",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "aws-smithy-xml",
 + "aws-types",
 + "fastrand",
 + "http 0.2.12",
 + "regex-lite",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-sigv4"
 +version = "1.3.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "69e523e1c4e8e7e8ff219d732988e22bfeae8a1cafdbe6d9eca1546fa080be7c"
 +dependencies = [
 + "aws-credential-types",
 + "aws-smithy-eventstream",
 + "aws-smithy-http",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "bytes",
 + "crypto-bigint 0.5.5",
 + "form_urlencoded",
 + "hex",
 + "hmac",
 + "http 0.2.12",
 + "http 1.4.0",
 + "p256",
 + "percent-encoding",
 + "ring",
 + "sha2",
 + "subtle",
 + "time",
 + "tracing",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "aws-smithy-async"
 +version = "1.2.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9ee19095c7c4dda59f1697d028ce704c24b2d33c6718790c7f1d5a3015b4107c"
 +dependencies = [
 + "futures-util",
 + "pin-project-lite",
 + "tokio",
 +]
++
 +[[package]]
 +name = "aws-smithy-checksums"
 +version = "0.63.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "87294a084b43d649d967efe58aa1f9e0adc260e13a6938eb904c0ae9b45824ae"
 +dependencies = [
 + "aws-smithy-http",
 + "aws-smithy-types",
 + "bytes",
 + "crc-fast",
 + "hex",
 + "http 0.2.12",
 + "http-body 0.4.6",
 + "md-5",
 + "pin-project-lite",
 + "sha1",
 + "sha2",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-smithy-eventstream"
 +version = "0.60.14"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "dc12f8b310e38cad85cf3bef45ad236f470717393c613266ce0a89512286b650"
 +dependencies = [
 + "aws-smithy-types",
 + "bytes",
 + "crc32fast",
 +]
++
 +[[package]]
 +name = "aws-smithy-http"
 +version = "0.62.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "826141069295752372f8203c17f28e30c464d22899a43a0c9fd9c458d469c88b"
 +dependencies = [
 + "aws-smithy-eventstream",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "bytes",
 + "bytes-utils",
 + "futures-core",
 + "futures-util",
 + "http 0.2.12",
 + "http 1.4.0",
 + "http-body 0.4.6",
 + "percent-encoding",
 + "pin-project-lite",
 + "pin-utils",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-smithy-http-client"
 +version = "1.1.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "59e62db736db19c488966c8d787f52e6270be565727236fd5579eaa301e7bc4a"
 +dependencies = [
 + "aws-smithy-async",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "h2 0.3.27",
 + "h2 0.4.13",
 + "http 0.2.12",
 + "http 1.4.0",
 + "http-body 0.4.6",
 + "hyper 0.14.32",
 + "hyper 1.8.1",
 + "hyper-rustls 0.24.2",
 + "hyper-rustls 0.27.7",
 + "hyper-util",
 + "pin-project-lite",
 + "rustls 0.21.12",
 + "rustls 0.23.36",
 + "rustls-native-certs",
 + "rustls-pki-types",
 + "tokio",
 + "tokio-rustls 0.26.4",
 + "tower",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-smithy-json"
 +version = "0.61.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "49fa1213db31ac95288d981476f78d05d9cbb0353d22cdf3472cc05bb02f6551"
 +dependencies = [
 + "aws-smithy-types",
 +]
++
 +[[package]]
 +name = "aws-smithy-observability"
 +version = "0.1.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "17f616c3f2260612fe44cede278bafa18e73e6479c4e393e2c4518cf2a9a228a"
 +dependencies = [
 + "aws-smithy-runtime-api",
 +]
++
 +[[package]]
 +name = "aws-smithy-query"
 +version = "0.60.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ae5d689cf437eae90460e944a58b5668530d433b4ff85789e69d2f2a556e057d"
 +dependencies = [
 + "aws-smithy-types",
 + "urlencoding",
 +]
++
 +[[package]]
 +name = "aws-smithy-runtime"
 +version = "1.9.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "a392db6c583ea4a912538afb86b7be7c5d8887d91604f50eb55c262ee1b4a5f5"
 +dependencies = [
 + "aws-smithy-async",
 + "aws-smithy-http",
 + "aws-smithy-http-client",
 + "aws-smithy-observability",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "bytes",
 + "fastrand",
 + "http 0.2.12",
 + "http 1.4.0",
 + "http-body 0.4.6",
 + "http-body 1.0.1",
 + "pin-project-lite",
 + "pin-utils",
 + "tokio",
 + "tracing",
 +]
++
 +[[package]]
 +name = "aws-smithy-runtime-api"
 +version = "1.9.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ab0d43d899f9e508300e587bf582ba54c27a452dd0a9ea294690669138ae14a2"
 +dependencies = [
 + "aws-smithy-async",
 + "aws-smithy-types",
 + "bytes",
 + "http 0.2.12",
 + "http 1.4.0",
 + "pin-project-lite",
 + "tokio",
 + "tracing",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "aws-smithy-types"
 +version = "1.3.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "905cb13a9895626d49cf2ced759b062d913834c7482c38e49557eac4e6193f01"
 +dependencies = [
 + "base64-simd",
 + "bytes",
 + "bytes-utils",
 + "futures-core",
 + "http 0.2.12",
 + "http 1.4.0",
 + "http-body 0.4.6",
 + "http-body 1.0.1",
 + "http-body-util",
 + "itoa",
 + "num-integer",
 + "pin-project-lite",
 + "pin-utils",
 + "ryu",
 + "serde",
 + "time",
 + "tokio",
 + "tokio-util",
 +]
++
 +[[package]]
 +name = "aws-smithy-xml"
 +version = "0.60.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "11b2f670422ff42bf7065031e72b45bc52a3508bd089f743ea90731ca2b6ea57"
 +dependencies = [
 + "xmlparser",
 +]
++
 +[[package]]
 +name = "aws-types"
 +version = "1.3.11"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1d980627d2dd7bfc32a3c025685a033eeab8d365cc840c631ef59d1b8f428164"
 +dependencies = [
 + "aws-credential-types",
 + "aws-smithy-async",
 + "aws-smithy-runtime-api",
 + "aws-smithy-types",
 + "rustc_version",
 + "tracing",
 +]
++
 +[[package]]
 +name = "base16ct"
 +version = "0.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"
++
  [[package]]
  name = "base64"
  version = "0.22.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 +[[package]]
 +name = "base64-simd"
 +version = "0.8.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
 +dependencies = [
 + "outref",
 + "vsimd",
 +]
++
 +[[package]]
 +name = "base64ct"
 +version = "1.8.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
++
 +[[package]]
 +name = "bindgen"
 +version = "0.70.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
 +dependencies = [
 + "bitflags",
 + "cexpr",
 + "clang-sys",
 + "itertools",
 + "proc-macro2",
 + "quote",
 + "regex",
 + "rustc-hash",
 + "shlex",
 + "syn",
 +]
++
  [[package]]
  name = "bitflags"
  version = "2.10.0"
   "cpufeatures",
+ ]
 +[[package]]
 +name = "block-buffer"
 +version = "0.10.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 +dependencies = [
 + "generic-array",
 +]
++
  [[package]]
  name = "bumpalo"
  version = "3.19.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 +[[package]]
 +name = "bytes-utils"
 +version = "0.1.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
 +dependencies = [
 + "bytes",
 + "either",
 +]
++
  [[package]]
  name = "cc"
  version = "1.2.52"
  checksum = "cd4932aefd12402b36c60956a4fe0035421f544799057659ff86f923657aada3"
  dependencies = [
   "find-msvc-tools",
 + "jobserver",
 + "libc",
   "shlex",
+ ]
 +[[package]]
 +name = "cexpr"
 +version = "0.6.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
 +dependencies = [
 + "nom",
 +]
++
  [[package]]
  name = "cfg-if"
  version = "1.0.4"
   "windows-link",
+ ]
 +[[package]]
 +name = "clang-sys"
 +version = "1.8.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 +dependencies = [
 + "glob",
 + "libc",
 + "libloading",
 +]
++
  [[package]]
  name = "clap"
  version = "4.5.54"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 +[[package]]
 +name = "cmake"
 +version = "0.1.57"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
 +dependencies = [
 + "cc",
 +]
++
  [[package]]
  name = "color_quant"
  version = "1.1.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 +[[package]]
 +name = "console"
 +version = "0.15.11"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
 +dependencies = [
 + "encode_unicode",
 + "libc",
 + "once_cell",
 + "unicode-width",
 + "windows-sys 0.59.0",
 +]
++
 +[[package]]
 +name = "const-oid"
 +version = "0.9.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
++
  [[package]]
  name = "constant_time_eq"
  version = "0.4.2"
   "libc",
+ ]
 +[[package]]
 +name = "core-foundation"
 +version = "0.10.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
 +dependencies = [
 + "core-foundation-sys",
 + "libc",
 +]
++
  [[package]]
  name = "core-foundation-sys"
  version = "0.8.7"
   "libc",
+ ]
 +[[package]]
 +name = "crc"
 +version = "3.4.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
 +dependencies = [
 + "crc-catalog",
 +]
++
 +[[package]]
 +name = "crc-catalog"
 +version = "2.4.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
++
 +[[package]]
 +name = "crc-fast"
 +version = "1.6.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6ddc2d09feefeee8bd78101665bd8645637828fa9317f9f292496dbbd8c65ff3"
 +dependencies = [
 + "crc",
 + "digest",
 + "rand 0.9.2",
 + "regex",
 + "rustversion",
 +]
++
  [[package]]
  name = "crc32fast"
  version = "1.5.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 +[[package]]
 +name = "crypto-bigint"
 +version = "0.4.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef"
 +dependencies = [
 + "generic-array",
 + "rand_core 0.6.4",
 + "subtle",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "crypto-bigint"
 +version = "0.5.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 +dependencies = [
 + "rand_core 0.6.4",
 + "subtle",
 +]
++
 +[[package]]
 +name = "crypto-common"
 +version = "0.1.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 +dependencies = [
 + "generic-array",
 + "typenum",
 +]
++
  [[package]]
  name = "cssparser"
  version = "0.31.2"
   "syn",
+ ]
 +[[package]]
 +name = "der"
 +version = "0.6.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de"
 +dependencies = [
 + "const-oid",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "deranged"
 +version = "0.5.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
 +dependencies = [
 + "powerfmt",
 +]
++
  [[package]]
  name = "derive_more"
  version = "0.99.20"
   "syn",
+ ]
 +[[package]]
 +name = "digest"
 +version = "0.10.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 +dependencies = [
 + "block-buffer",
 + "crypto-common",
 + "subtle",
 +]
++
  [[package]]
  name = "dirs"
  version = "6.0.0"
   "dtoa",
+ ]
 +[[package]]
 +name = "dunce"
 +version = "1.0.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
++
 +[[package]]
 +name = "ecdsa"
 +version = "0.14.8"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c"
 +dependencies = [
 + "der",
 + "elliptic-curve",
 + "rfc6979",
 + "signature",
 +]
++
  [[package]]
  name = "ego-tree"
  version = "0.6.3"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "12a0bb14ac04a9fcf170d0bbbef949b44cc492f4452bd20c095636956f653642"
 +[[package]]
 +name = "either"
 +version = "1.15.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
++
 +[[package]]
 +name = "elliptic-curve"
 +version = "0.12.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3"
 +dependencies = [
 + "base16ct",
 + "crypto-bigint 0.4.9",
 + "der",
 + "digest",
 + "ff",
 + "generic-array",
 + "group",
 + "pkcs8",
 + "rand_core 0.6.4",
 + "sec1",
 + "subtle",
 + "zeroize",
 +]
++
 +[[package]]
 +name = "encode_unicode"
 +version = "1.0.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
++
  [[package]]
  name = "encoding_rs"
  version = "0.8.35"
   "simd-adler32",
+ ]
 +[[package]]
 +name = "ff"
 +version = "0.12.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160"
 +dependencies = [
 + "rand_core 0.6.4",
 + "subtle",
 +]
++
 +[[package]]
 +name = "ffmpeg-next"
 +version = "7.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "da02698288e0275e442a47fc12ca26d50daf0d48b15398ba5906f20ac2e2a9f9"
 +dependencies = [
 + "bitflags",
 + "ffmpeg-sys-next",
 + "libc",
 +]
++
 +[[package]]
 +name = "ffmpeg-sys-next"
 +version = "7.1.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f9e9c75ebd4463de9d8998fb134ba26347fe5faee62fabf0a4b4d41bd500b4ad"
 +dependencies = [
 + "bindgen",
 + "cc",
 + "libc",
 + "num_cpus",
 + "pkg-config",
 + "vcpkg",
 +]
++
  [[package]]
  name = "find-msvc-tools"
  version = "0.1.7"
   "percent-encoding",
+ ]
 +[[package]]
 +name = "fs_extra"
 +version = "1.3.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
++
  [[package]]
  name = "futf"
  version = "0.1.5"
  dependencies = [
   "anyhow",
   "async-trait",
 + "aws-config",
 + "aws-sdk-s3",
   "blake3",
   "chrono",
   "clap",
   "crossbeam-channel",
   "dirs",
 + "ffmpeg-next",
   "humantime",
   "image",
 + "indicatif",
   "lru",
 - "rand",
 + "rand 0.8.5",
   "reqwest",
   "scraper",
   "serde",
   "x11rb",
+ ]
 +[[package]]
 +name = "generic-array"
 +version = "0.14.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 +dependencies = [
 + "typenum",
 + "version_check",
 +]
++
  [[package]]
  name = "gethostname"
  version = "1.1.0"
   "weezl",
+ ]
 +[[package]]
 +name = "glob"
 +version = "0.3.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
++
 +[[package]]
 +name = "group"
 +version = "0.12.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7"
 +dependencies = [
 + "ff",
 + "rand_core 0.6.4",
 + "subtle",
 +]
++
 +[[package]]
 +name = "h2"
 +version = "0.3.27"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
 +dependencies = [
 + "bytes",
 + "fnv",
 + "futures-core",
 + "futures-sink",
 + "futures-util",
 + "http 0.2.12",
 + "indexmap",
 + "slab",
 + "tokio",
 + "tokio-util",
 + "tracing",
 +]
++
  [[package]]
  name = "h2"
  version = "0.4.13"
   "fnv",
   "futures-core",
   "futures-sink",
 - "http",
 + "http 1.4.0",
   "indexmap",
   "slab",
   "tokio",
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 +[[package]]
 +name = "hermit-abi"
 +version = "0.5.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
++
 +[[package]]
 +name = "hex"
 +version = "0.4.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
++
 +[[package]]
 +name = "hmac"
 +version = "0.12.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
 +dependencies = [
 + "digest",
 +]
++
  [[package]]
  name = "html5ever"
  version = "0.27.0"
   "syn",
+ ]
 +[[package]]
 +name = "http"
 +version = "0.2.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
 +dependencies = [
 + "bytes",
 + "fnv",
 + "itoa",
 +]
++
  [[package]]
  name = "http"
  version = "1.4.0"
   "itoa",
+ ]
 +[[package]]
 +name = "http-body"
 +version = "0.4.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 +dependencies = [
 + "bytes",
 + "http 0.2.12",
 + "pin-project-lite",
 +]
++
  [[package]]
  name = "http-body"
  version = "1.0.1"
  checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
  dependencies = [
   "bytes",
 - "http",
 + "http 1.4.0",
+ ]
  [[package]]
  dependencies = [
   "bytes",
   "futures-core",
 - "http",
 - "http-body",
 + "http 1.4.0",
 + "http-body 1.0.1",
   "pin-project-lite",
+ ]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 +[[package]]
 +name = "httpdate"
 +version = "1.0.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
++
  [[package]]
  name = "humantime"
  version = "2.3.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
 +[[package]]
 +name = "hyper"
 +version = "0.14.32"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
 +dependencies = [
 + "bytes",
 + "futures-channel",
 + "futures-core",
 + "futures-util",
 + "h2 0.3.27",
 + "http 0.2.12",
 + "http-body 0.4.6",
 + "httparse",
 + "httpdate",
 + "itoa",
 + "pin-project-lite",
 + "socket2 0.5.10",
 + "tokio",
 + "tower-service",
 + "tracing",
 + "want",
 +]
++
  [[package]]
  name = "hyper"
  version = "1.8.1"
   "bytes",
   "futures-channel",
   "futures-core",
 - "h2",
 - "http",
 - "http-body",
 + "h2 0.4.13",
 + "http 1.4.0",
 + "http-body 1.0.1",
   "httparse",
   "itoa",
   "pin-project-lite",
   "want",
+ ]
 +[[package]]
 +name = "hyper-rustls"
 +version = "0.24.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 +dependencies = [
 + "futures-util",
 + "http 0.2.12",
 + "hyper 0.14.32",
 + "log",
 + "rustls 0.21.12",
 + "tokio",
 + "tokio-rustls 0.24.1",
 +]
++
  [[package]]
  name = "hyper-rustls"
  version = "0.27.7"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
  dependencies = [
 - "http",
 - "hyper",
 + "http 1.4.0",
 + "hyper 1.8.1",
   "hyper-util",
 - "rustls",
 + "rustls 0.23.36",
 + "rustls-native-certs",
   "rustls-pki-types",
   "tokio",
 - "tokio-rustls",
 + "tokio-rustls 0.26.4",
   "tower-service",
+ ]
  dependencies = [
   "bytes",
   "http-body-util",
 - "hyper",
 + "hyper 1.8.1",
   "hyper-util",
   "native-tls",
   "tokio",
   "futures-channel",
   "futures-core",
   "futures-util",
 - "http",
 - "http-body",
 - "hyper",
 + "http 1.4.0",
 + "http-body 1.0.1",
 + "hyper 1.8.1",
   "ipnet",
   "libc",
   "percent-encoding",
   "pin-project-lite",
 - "socket2",
 + "socket2 0.6.1",
   "system-configuration",
   "tokio",
   "tower-service",
   "hashbrown 0.16.1",
+ ]
 +[[package]]
 +name = "indicatif"
 +version = "0.17.11"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
 +dependencies = [
 + "console",
 + "number_prefix",
 + "portable-atomic",
 + "unicode-width",
 + "web-time",
 +]
++
  [[package]]
  name = "ipnet"
  version = "2.11.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 +[[package]]
 +name = "itertools"
 +version = "0.13.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
 +dependencies = [
 + "either",
 +]
++
  [[package]]
  name = "itoa"
  version = "1.0.17"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 +[[package]]
 +name = "jobserver"
 +version = "0.1.34"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 +dependencies = [
 + "getrandom 0.3.4",
 + "libc",
 +]
++
  [[package]]
  name = "js-sys"
  version = "0.3.83"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 +[[package]]
 +name = "libloading"
 +version = "0.8.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 +dependencies = [
 + "cfg-if",
 + "windows-link",
 +]
++
  [[package]]
  name = "libredox"
  version = "0.1.12"
   "regex-automata",
+ ]
 +[[package]]
 +name = "md-5"
 +version = "0.10.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
 +dependencies = [
 + "cfg-if",
 + "digest",
 +]
++
  [[package]]
  name = "memchr"
  version = "2.7.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 +[[package]]
 +name = "minimal-lexical"
 +version = "0.2.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
++
  [[package]]
  name = "miniz_oxide"
  version = "0.8.9"
   "libc",
   "log",
   "openssl",
 - "openssl-probe",
 + "openssl-probe 0.1.6",
   "openssl-sys",
   "schannel",
 - "security-framework",
 + "security-framework 2.11.1",
   "security-framework-sys",
   "tempfile",
+ ]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 +[[package]]
 +name = "nom"
 +version = "7.1.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 +dependencies = [
 + "memchr",
 + "minimal-lexical",
 +]
++
  [[package]]
  name = "nu-ansi-term"
  version = "0.50.3"
   "windows-sys 0.61.2",
+ ]
 +[[package]]
 +name = "num-conv"
 +version = "0.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
++
 +[[package]]
 +name = "num-integer"
 +version = "0.1.46"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 +dependencies = [
 + "num-traits",
 +]
++
  [[package]]
  name = "num-traits"
  version = "0.2.19"
   "autocfg",
+ ]
 +[[package]]
 +name = "num_cpus"
 +version = "1.17.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 +dependencies = [
 + "hermit-abi",
 + "libc",
 +]
++
 +[[package]]
 +name = "number_prefix"
 +version = "0.4.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
++
  [[package]]
  name = "once_cell"
  version = "1.21.3"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 +[[package]]
 +name = "openssl-probe"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391"
++
  [[package]]
  name = "openssl-sys"
  version = "0.9.111"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 +[[package]]
 +name = "outref"
 +version = "0.5.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
++
 +[[package]]
 +name = "p256"
 +version = "0.11.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "51f44edd08f51e2ade572f141051021c5af22677e42b7dd28a88155151c33594"
 +dependencies = [
 + "ecdsa",
 + "elliptic-curve",
 + "sha2",
 +]
++
  [[package]]
  name = "parking_lot"
  version = "0.12.5"
  checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
  dependencies = [
   "phf_shared 0.10.0",
 - "rand",
 + "rand 0.8.5",
+ ]
  [[package]]
  checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
  dependencies = [
   "phf_shared 0.11.3",
 - "rand",
 + "rand 0.8.5",
+ ]
  [[package]]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 +[[package]]
 +name = "pkcs8"
 +version = "0.9.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba"
 +dependencies = [
 + "der",
 + "spki",
 +]
++
  [[package]]
  name = "pkg-config"
  version = "0.3.32"
   "miniz_oxide",
+ ]
 +[[package]]
 +name = "portable-atomic"
 +version = "1.13.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
++
  [[package]]
  name = "potential_utf"
  version = "0.1.4"
   "zerovec",
+ ]
 +[[package]]
 +name = "powerfmt"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
++
  [[package]]
  name = "ppv-lite86"
  version = "0.2.21"
  checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
  dependencies = [
   "libc",
 - "rand_chacha",
 - "rand_core",
 + "rand_chacha 0.3.1",
 + "rand_core 0.6.4",
 +]
++
 +[[package]]
 +name = "rand"
 +version = "0.9.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 +dependencies = [
 + "rand_chacha 0.9.0",
 + "rand_core 0.9.4",
+ ]
  [[package]]
  checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
  dependencies = [
   "ppv-lite86",
 - "rand_core",
 + "rand_core 0.6.4",
 +]
++
 +[[package]]
 +name = "rand_chacha"
 +version = "0.9.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 +dependencies = [
 + "ppv-lite86",
 + "rand_core 0.9.4",
+ ]
  [[package]]
   "getrandom 0.2.17",
+ ]
 +[[package]]
 +name = "rand_core"
 +version = "0.9.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "4f1b3bc831f92381018fd9c6350b917c7b21f1eed35a65a51900e0e55a3d7afa"
 +dependencies = [
 + "getrandom 0.3.4",
 +]
++
  [[package]]
  name = "redox_syscall"
  version = "0.5.18"
   "thiserror",
+ ]
 +[[package]]
 +name = "regex"
 +version = "1.12.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 +dependencies = [
 + "aho-corasick",
 + "memchr",
 + "regex-automata",
 + "regex-syntax",
 +]
++
  [[package]]
  name = "regex-automata"
  version = "0.4.13"
   "regex-syntax",
+ ]
 +[[package]]
 +name = "regex-lite"
 +version = "0.1.8"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
++
  [[package]]
  name = "regex-syntax"
  version = "0.8.8"
   "futures-channel",
   "futures-core",
   "futures-util",
 - "h2",
 - "http",
 - "http-body",
 + "h2 0.4.13",
 + "http 1.4.0",
 + "http-body 1.0.1",
   "http-body-util",
 - "hyper",
 - "hyper-rustls",
 + "hyper 1.8.1",
 + "hyper-rustls 0.27.7",
   "hyper-tls",
   "hyper-util",
   "js-sys",
   "web-sys",
+ ]
 +[[package]]
 +name = "rfc6979"
 +version = "0.3.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb"
 +dependencies = [
 + "crypto-bigint 0.4.9",
 + "hmac",
 + "zeroize",
 +]
++
  [[package]]
  name = "ring"
  version = "0.17.14"
   "windows-sys 0.52.0",
+ ]
 +[[package]]
 +name = "rustc-hash"
 +version = "1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
++
 +[[package]]
 +name = "rustc_version"
 +version = "0.4.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 +dependencies = [
 + "semver",
 +]
++
  [[package]]
  name = "rustix"
  version = "1.1.3"
   "windows-sys 0.61.2",
+ ]
 +[[package]]
 +name = "rustls"
 +version = "0.21.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 +dependencies = [
 + "log",
 + "ring",
 + "rustls-webpki 0.101.7",
 + "sct",
 +]
++
  [[package]]
  name = "rustls"
  version = "0.23.36"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
  dependencies = [
 + "aws-lc-rs",
   "once_cell",
   "rustls-pki-types",
 - "rustls-webpki",
 + "rustls-webpki 0.103.8",
   "subtle",
   "zeroize",
+ ]
 +[[package]]
 +name = "rustls-native-certs"
 +version = "0.8.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 +dependencies = [
 + "openssl-probe 0.2.0",
 + "rustls-pki-types",
 + "schannel",
 + "security-framework 3.5.1",
 +]
++
  [[package]]
  name = "rustls-pki-types"
  version = "1.13.2"
   "zeroize",
+ ]
 +[[package]]
 +name = "rustls-webpki"
 +version = "0.101.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 +dependencies = [
 + "ring",
 + "untrusted",
 +]
++
  [[package]]
  name = "rustls-webpki"
  version = "0.103.8"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
  dependencies = [
 + "aws-lc-rs",
   "ring",
   "rustls-pki-types",
   "untrusted",
   "tendril",
+ ]
 +[[package]]
 +name = "sct"
 +version = "0.7.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 +dependencies = [
 + "ring",
 + "untrusted",
 +]
++
 +[[package]]
 +name = "sec1"
 +version = "0.3.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928"
 +dependencies = [
 + "base16ct",
 + "der",
 + "generic-array",
 + "pkcs8",
 + "subtle",
 + "zeroize",
 +]
++
  [[package]]
  name = "security-framework"
  version = "2.11.1"
  checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
  dependencies = [
   "bitflags",
 - "core-foundation",
 + "core-foundation 0.9.4",
 + "core-foundation-sys",
 + "libc",
 + "security-framework-sys",
 +]
++
 +[[package]]
 +name = "security-framework"
 +version = "3.5.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
 +dependencies = [
 + "bitflags",
 + "core-foundation 0.10.1",
   "core-foundation-sys",
   "libc",
   "security-framework-sys",
   "smallvec",
+ ]
 +[[package]]
 +name = "semver"
 +version = "1.0.27"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
++
  [[package]]
  name = "serde"
  version = "1.0.228"
   "stable_deref_trait",
+ ]
 +[[package]]
 +name = "sha1"
 +version = "0.10.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 +dependencies = [
 + "cfg-if",
 + "cpufeatures",
 + "digest",
 +]
++
 +[[package]]
 +name = "sha2"
 +version = "0.10.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 +dependencies = [
 + "cfg-if",
 + "cpufeatures",
 + "digest",
 +]
++
  [[package]]
  name = "sharded-slab"
  version = "0.1.7"
   "libc",
+ ]
 +[[package]]
 +name = "signature"
 +version = "1.6.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
 +dependencies = [
 + "digest",
 + "rand_core 0.6.4",
 +]
++
  [[package]]
  name = "simd-adler32"
  version = "0.3.8"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 +[[package]]
 +name = "socket2"
 +version = "0.5.10"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
 +dependencies = [
 + "libc",
 + "windows-sys 0.52.0",
 +]
++
  [[package]]
  name = "socket2"
  version = "0.6.1"
   "windows-sys 0.60.2",
+ ]
 +[[package]]
 +name = "spki"
 +version = "0.6.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b"
 +dependencies = [
 + "base64ct",
 + "der",
 +]
++
  [[package]]
  name = "stable_deref_trait"
  version = "1.2.1"
  checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
  dependencies = [
   "bitflags",
 - "core-foundation",
 + "core-foundation 0.9.4",
   "system-configuration-sys",
+ ]
   "cfg-if",
+ ]
 +[[package]]
 +name = "time"
 +version = "0.3.44"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
 +dependencies = [
 + "deranged",
 + "num-conv",
 + "powerfmt",
 + "serde",
 + "time-core",
 + "time-macros",
 +]
++
 +[[package]]
 +name = "time-core"
 +version = "0.1.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
++
 +[[package]]
 +name = "time-macros"
 +version = "0.2.24"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
 +dependencies = [
 + "num-conv",
 + "time-core",
 +]
++
  [[package]]
  name = "tinystr"
  version = "0.8.2"
   "parking_lot",
   "pin-project-lite",
   "signal-hook-registry",
 - "socket2",
 + "socket2 0.6.1",
   "tokio-macros",
   "windows-sys 0.61.2",
+ ]
   "tokio",
+ ]
 +[[package]]
 +name = "tokio-rustls"
 +version = "0.24.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 +dependencies = [
 + "rustls 0.21.12",
 + "tokio",
 +]
++
  [[package]]
  name = "tokio-rustls"
  version = "0.26.4"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
  dependencies = [
 - "rustls",
 + "rustls 0.23.36",
   "tokio",
+ ]
   "bitflags",
   "bytes",
   "futures-util",
 - "http",
 - "http-body",
 + "http 1.4.0",
 + "http-body 1.0.1",
   "iri-string",
   "pin-project-lite",
   "tower",
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 +[[package]]
 +name = "typenum"
 +version = "1.19.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
++
  [[package]]
  name = "unicode-ident"
  version = "1.0.22"
   "serde",
+ ]
 +[[package]]
 +name = "urlencoding"
 +version = "2.1.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
++
  [[package]]
  name = "utf-8"
  version = "0.7.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 +[[package]]
 +name = "uuid"
 +version = "1.19.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
 +dependencies = [
 + "js-sys",
 + "wasm-bindgen",
 +]
++
  [[package]]
  name = "valuable"
  version = "0.1.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 +[[package]]
 +name = "vsimd"
 +version = "0.8.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
++
  [[package]]
  name = "want"
  version = "0.3.1"
   "wasm-bindgen",
+ ]
 +[[package]]
 +name = "web-time"
 +version = "1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 +dependencies = [
 + "js-sys",
 + "wasm-bindgen",
 +]
++
  [[package]]
  name = "weezl"
  version = "0.1.12"
   "windows-targets 0.52.6",
+ ]
 +[[package]]
 +name = "windows-sys"
 +version = "0.59.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 +dependencies = [
 + "windows-targets 0.52.6",
 +]
++
  [[package]]
  name = "windows-sys"
  version = "0.60.2"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 +[[package]]
 +name = "xmlparser"
 +version = "0.13.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
++
  [[package]]
  name = "yoke"
  version = "0.8.1"

Cargo.tomlmodified

  # Random selection
  rand = "0.8"
++
 +# Progress indicators
 +indicatif = "0.17"
++
 +# S3 support (optional)
 +aws-config = "1"
 +aws-sdk-s3 = "1"
++
 +# Video support (optional)
 +ffmpeg-next = "7"

DEFERRED.mdadded

 +# Deferred Targets - Completion Checklist
++
 +Complete all items before Phase 5. Ordered by effort (low → high).
++
 +---
++
 +## Low Effort
++
 +### Phase 4: PID File Management
 +- [x] Write PID to `$XDG_RUNTIME_DIR/garbg.pid` on daemon start
 +- [x] Check for stale PID file and clean up
 +- [x] Remove PID file on graceful shutdown
++
 +### Phase 4: Signal Handling
 +- [x] Handle SIGHUP → reload configuration
 +- [x] Handle SIGTERM → graceful shutdown
 +- [x] Handle SIGINT → graceful shutdown
++
 +### Phase 3: Wire Disk Cache to Daemon
 +- [x] Use DiskCache when fetching remote images in daemon
 +- [x] Check cache before HTTP fetch
 +- [x] Store fetched images in cache
++
 +### Phase 4: Test gar Integration
 +- [x] Verify gar IPC connection works
 +- [x] Test workspace change events trigger wallpaper switch
 +- [x] Fix any parsing issues with gar events
++
 +---
++
 +## Medium Effort
++
 +### Phase 3: Wire Provider Trait Architecture
 +- [x] Refactor HTTP fetching to use HttpProvider
 +- [x] Refactor GitHub fetching to use GitHubProvider
 +- [x] Refactor local files to use FileProvider
 +- [x] Use ProviderRegistry for URI dispatch
 +- [x] Remove ad-hoc implementations from main.rs
++
 +### Phase 2: Animated WebP Support
 +- [x] Detect animated WebP files
 +- [x] Use image crate's WebP animation support (if available)
 +- [x] Integrate with existing AnimatedGif infrastructure
 +- [x] Test with sample animated WebP files
++
 +### Phase 2: Frame Pre-rendering Ring Buffer
 +- [x] Create ring buffer struct (~30 frames)
 +- [x] Background thread for frame decoding
 +- [x] Producer-consumer with crossbeam channels
 +- [x] Memory-efficient frame recycling
++
 +### Phase 3: S3 Provider
 +- [x] Add `s3` feature flag
 +- [x] Parse `s3://bucket/prefix` URIs
 +- [x] List objects with prefix (aws-sdk-s3 or rusoto)
 +- [x] Support S3-compatible endpoints (MinIO)
 +- [x] Handle authentication (env vars, credentials file)
++
 +---
++
 +## High Effort
++
 +### Phase 2: Animated PNG (APNG) Support
 +- [x] Add APNG decoder (png crate or apng crate)
 +- [x] Extract frames and delays
 +- [x] Integrate with animation infrastructure
 +- [x] Test with sample APNG files
++
 +### Phase 2: Video Decoding (ffmpeg-next)
 +- [x] Add `video` feature flag
 +- [x] Integrate ffmpeg-next crate
 +- [x] Decode video frames to RGBA
 +- [x] Handle common codecs (H.264, VP9, AV1)
 +- [x] Support MP4 and WebM containers
 +- [x] Audio always muted (no PulseAudio complexity)
 +- [x] Integrate with animation loop for playback
++
 +---
++
 +## Progress Tracker
++
 +| Phase | Section | Status |
 +|-------|---------|--------|
 +| 4 | PID File | ✅ |
 +| 4 | Signal Handling | ✅ |
 +| 3 | Disk Cache in Daemon | ✅ |
 +| 4 | Test gar Integration | ✅ |
 +| 3 | Provider Trait Wiring | ✅ |
 +| 2 | Animated WebP | ✅ |
 +| 2 | Ring Buffer | ✅ |
 +| 3 | S3 Provider | ✅ |
 +| 2 | APNG Support | ✅ |
 +| 2 | Video Decoding | ✅ |
++
 +---
++
 +## Completion Criteria
++
 +All boxes checked = Ready for Phase 5 (Lua, multi-monitor, docs)
++
 +**STATUS: COMPLETE** - All deferred targets implemented!

garbg/Cargo.tomlmodified

  shellexpand.workspace = true
  url.workspace = true
  rand.workspace = true
 +indicatif.workspace = true
  [features]
 -default = []
 -# Video support via ffmpeg (optional, requires system ffmpeg)
 -video = []
 -# S3/object storage support
 -s3 = []
 +default = ["video"]
 +# Video support via ffmpeg (requires system ffmpeg-dev libraries)
 +video = ["dep:ffmpeg-next"]
 +# S3/object storage support (optional, for cloud storage)
 +s3 = ["dep:aws-config", "dep:aws-sdk-s3"]
++
 +[dependencies.aws-config]
 +version = "1"
 +optional = true
++
 +[dependencies.aws-sdk-s3]
 +version = "1"
 +optional = true
++
 +[dependencies.ffmpeg-next]
 +version = "7"
 +optional = true

garbg/src/cache/disk.rsmodified

  use anyhow::{Context, Result};
  use serde::{Deserialize, Serialize};
  use std::collections::HashMap;
 -use std::path::{Path, PathBuf};
 +use std::path::PathBuf;
  use std::time::SystemTime;
  /// Disk cache for remote images

garbg/src/config/types.rsmodified

  //! Configuration type definitions
  use serde::{Deserialize, Serialize};
 -use std::collections::HashMap;
  use std::str::FromStr;
  use std::time::Duration;

garbg/src/daemon/mod.rsmodified

  mod state;
  mod animation_loop;
 +mod pid;
  pub use state::{Daemon, DaemonState};
  pub use animation_loop::{AnimationLoop, AnimationConfig, AnimationInfo};
 +pub use pid::{check_stale_pid, is_daemon_running_by_pid, pid_file_path, read_pid_file, remove_pid_file, write_pid_file};

garbg/src/daemon/pid.rsadded

 +//! PID file management for daemon lifecycle
++
 +use anyhow::{Context, Result};
 +use std::fs;
 +use std::io::{Read, Write};
 +use std::path::PathBuf;
 +use std::process;
++
 +/// Get the path to the PID file
 +pub fn pid_file_path() -> Result<PathBuf> {
 +    let runtime_dir = std::env::var("XDG_RUNTIME_DIR")
 +        .unwrap_or_else(|_| "/tmp".to_string());
 +    Ok(PathBuf::from(runtime_dir).join("garbg.pid"))
 +}
++
 +/// Write the current process PID to the PID file
 +pub fn write_pid_file() -> Result<()> {
 +    let path = pid_file_path()?;
 +    let pid = process::id();
++
 +    let mut file = fs::File::create(&path)
 +        .with_context(|| format!("Failed to create PID file: {}", path.display()))?;
++
 +    write!(file, "{}", pid)
 +        .with_context(|| format!("Failed to write PID to: {}", path.display()))?;
++
 +    tracing::debug!("PID file written: {} (pid: {})", path.display(), pid);
 +    Ok(())
 +}
++
 +/// Remove the PID file (for graceful shutdown)
 +pub fn remove_pid_file() -> Result<()> {
 +    let path = pid_file_path()?;
++
 +    if path.exists() {
 +        fs::remove_file(&path)
 +            .with_context(|| format!("Failed to remove PID file: {}", path.display()))?;
 +        tracing::debug!("PID file removed: {}", path.display());
 +    }
++
 +    Ok(())
 +}
++
 +/// Read the PID from the PID file, if it exists
 +pub fn read_pid_file() -> Result<Option<u32>> {
 +    let path = pid_file_path()?;
++
 +    if !path.exists() {
 +        return Ok(None);
 +    }
++
 +    let mut file = fs::File::open(&path)
 +        .with_context(|| format!("Failed to open PID file: {}", path.display()))?;
++
 +    let mut contents = String::new();
 +    file.read_to_string(&mut contents)
 +        .with_context(|| format!("Failed to read PID file: {}", path.display()))?;
++
 +    let pid = contents.trim().parse::<u32>()
 +        .with_context(|| format!("Invalid PID in file: {}", contents.trim()))?;
++
 +    Ok(Some(pid))
 +}
++
 +/// Check if a process with the given PID is running
 +fn is_process_running(pid: u32) -> bool {
 +    // On Unix, we can check if a process exists by sending signal 0
 +    #[cfg(unix)]
 +    {
 +        use std::ffi::c_int;
 +        extern "C" {
 +            fn kill(pid: c_int, sig: c_int) -> c_int;
 +        }
 +        // Signal 0 doesn't send a signal, just checks if process exists
 +        unsafe { kill(pid as c_int, 0) == 0 }
 +    }
++
 +    #[cfg(not(unix))]
 +    {
 +        // On non-Unix, assume process is running if we can't check
 +        true
 +    }
 +}
++
 +/// Check for stale PID file and clean up if necessary
 +///
 +/// Returns:
 +/// - Ok(None) if no PID file exists
 +/// - Ok(Some(pid)) if a daemon is already running
 +/// - Removes stale file and returns Ok(None) if daemon is not running
 +pub fn check_stale_pid() -> Result<Option<u32>> {
 +    let pid = match read_pid_file()? {
 +        Some(pid) => pid,
 +        None => return Ok(None),
 +    };
++
 +    // Check if the process is actually running
 +    if is_process_running(pid) {
 +        // Daemon is already running
 +        tracing::debug!("Found running daemon with PID: {}", pid);
 +        return Ok(Some(pid));
 +    }
++
 +    // Stale PID file - daemon crashed or was killed without cleanup
 +    let path = pid_file_path()?;
 +    tracing::info!("Cleaning up stale PID file (pid {} not running)", pid);
++
 +    fs::remove_file(&path)
 +        .with_context(|| format!("Failed to remove stale PID file: {}", path.display()))?;
++
 +    Ok(None)
 +}
++
 +/// Check if another daemon instance is already running
 +pub fn is_daemon_running_by_pid() -> Result<bool> {
 +    Ok(check_stale_pid()?.is_some())
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_pid_file_path() {
 +        let path = pid_file_path().unwrap();
 +        assert!(path.to_string_lossy().ends_with("garbg.pid"));
 +    }
++
 +    #[test]
 +    fn test_is_process_running() {
 +        // Our own process should be running
 +        assert!(is_process_running(process::id()));
 +        // Very high PID probably doesn't exist
 +        assert!(!is_process_running(999999999));
 +    }
 +}

garbg/src/daemon/state.rsmodified

  use std::collections::HashMap;
  use std::time::Duration;
  use tokio::net::UnixStream;
 +use tokio::signal::unix::{signal, SignalKind};
 +use crate::cache::DiskCache;
  use crate::config::{Config, ScaleMode};
  use crate::ipc::{Command, GarEvent, GarIpcClient, IpcServer, Response};
  use crate::ipc::server::IpcClient;
 -use crate::media::{scale_image, AnimatedGif, ImageLoader};
 +use crate::media::{scale_image, AnimatedGif, AnimatedPng, AnimatedWebP, AnimationFrame, ImageLoader};
 +#[cfg(feature = "video")]
 +use crate::media::{VideoDecoder, is_video_file};
  use crate::state::{detect_source_type, PlaylistState};
  use crate::x11::{AnimationRenderer, Connection};
 +use super::pid;
++
  /// Current wallpaper state for a monitor
  #[derive(Debug, Clone)]
  pub struct MonitorWallpaper {
+     }
+ }
 -/// Active animation state
 +/// Active animation state (works with GIF, WebP, or other animated formats)
  pub struct ActiveAnimation {
 -    /// The animated GIF data
 -    gif: AnimatedGif,
      /// Pre-scaled frames for quick rendering
      scaled_frames: Vec<image::RgbaImage>,
 +    /// Frame delays (parallel to scaled_frames)
 +    frame_delays: Vec<Duration>,
      /// Animation renderer (double-buffered)
      renderer: AnimationRenderer,
      /// Current frame index
      current_frame: usize,
      /// Max FPS
      max_fps: u32,
 -    /// Scale mode
 +    /// Scale mode (for status)
 +    #[allow(dead_code)]
      scale_mode: ScaleMode,
      /// Source URI (for status)
 +    #[allow(dead_code)]
      source: String,
+ }
  impl ActiveAnimation {
 +    /// Create from animation frames
 +    fn from_frames(
 +        frames: &[AnimationFrame],
 +        renderer: AnimationRenderer,
 +        max_fps: u32,
 +        scale_mode: ScaleMode,
 +        source: String,
 +        screen_width: u32,
 +        screen_height: u32,
 +    ) -> Self {
 +        let scaled_frames: Vec<image::RgbaImage> = frames
 +            .iter()
 +            .map(|frame| scale_image(&frame.image, screen_width, screen_height, scale_mode))
 +            .collect();
++
 +        let frame_delays: Vec<Duration> = frames
 +            .iter()
 +            .map(|frame| frame.delay)
 +            .collect();
++
 +        Self {
 +            scaled_frames,
 +            frame_delays,
 +            renderer,
 +            current_frame: 0,
 +            max_fps,
 +            scale_mode,
 +            source,
 +        }
 +    }
++
      /// Get the delay for the current frame
      fn current_delay(&self) -> Duration {
 -        let frame_delay = self.gif.frames()[self.current_frame].delay;
 +        let frame_delay = self.frame_delays[self.current_frame];
          let min_delay = if self.max_fps > 0 {
              Duration::from_secs_f64(1.0 / self.max_fps as f64)
          } else {
              false
+         }
+     }
++
 +    /// Get frame count
 +    #[allow(dead_code)]
 +    fn frame_count(&self) -> usize {
 +        self.scaled_frames.len()
 +    }
+ }
  /// Main daemon struct
      /// Current animation (if playing)
      animation: Option<ActiveAnimation>,
++
 +    /// Disk cache for remote images
 +    cache: Option<DiskCache>,
+ }
  impl Daemon {
          let (width, height) = conn.screen_dimensions();
          tracing::info!("X11 connection established (screen: {}x{})", width, height);
 +        // Initialize disk cache
 +        let cache = match DiskCache::default_dir() {
 +            Some(cache_dir) => {
 +                let max_size_mb = config.cache.max_size_mb;
 +                match DiskCache::new(cache_dir.clone(), max_size_mb) {
 +                    Ok(cache) => {
 +                        tracing::info!("Disk cache initialized: {} (max {}MB)", cache_dir.display(), max_size_mb);
 +                        Some(cache)
 +                    }
 +                    Err(e) => {
 +                        tracing::warn!("Failed to initialize disk cache: {}", e);
 +                        None
 +                    }
 +                }
 +            }
 +            None => {
 +                tracing::warn!("No cache directory available, caching disabled");
 +                None
 +            }
 +        };
++
          let state = DaemonState::new(config);
          Ok(Self {
              conn,
              state,
              animation: None,
 +            cache,
          })
+     }
      /// Run the daemon event loop
      pub async fn run(&mut self) -> Result<()> {
 +        // Check for stale PID file and clean up
 +        if let Some(existing_pid) = pid::check_stale_pid()? {
 +            anyhow::bail!("Another daemon is already running (PID: {})", existing_pid);
 +        }
++
 +        // Write our PID file
 +        pid::write_pid_file()?;
++
 +        // Ensure cleanup on exit (both normal and panic)
 +        let _pid_guard = PidFileGuard;
++
          let server = IpcServer::new().await?;
          tracing::info!("Listening on {}", server.path().display());
          // Track next animation frame time
          let mut next_animation_frame: Option<tokio::time::Instant> = None;
 +        // Set up signal handlers
 +        let mut sigterm = signal(SignalKind::terminate())?;
 +        let mut sigint = signal(SignalKind::interrupt())?;
 +        let mut sighup = signal(SignalKind::hangup())?;
++
          // Main event loop
          loop {
              tokio::select! {
 +                // SIGTERM - graceful shutdown
 +                _ = sigterm.recv() => {
 +                    tracing::info!("Received SIGTERM, shutting down...");
 +                    break;
 +                }
++
 +                // SIGINT (Ctrl+C) - graceful shutdown
 +                _ = sigint.recv() => {
 +                    tracing::info!("Received SIGINT, shutting down...");
 +                    break;
 +                }
++
 +                // SIGHUP - reload configuration
 +                _ = sighup.recv() => {
 +                    tracing::info!("Received SIGHUP, reloading configuration...");
 +                    if let Err(e) = self.reload_config() {
 +                        tracing::error!("Failed to reload config: {}", e);
 +                    }
 +                }
++
                  // IPC client connection
                  result = server.accept() => {
                      match result {
+                 }
+             }
+         }
++
 +        // Graceful shutdown complete
 +        // PID file will be removed by PidFileGuard drop
 +        tracing::info!("Daemon shutdown complete");
 +        Ok(())
+     }
      /// Render the next animation frame
                  // Stop any existing animation first
                  self.animation = None;
 -                // Check if we should animate (GIF with animate flag)
 -                let is_gif = source.to_lowercase().ends_with(".gif")
 -                    || source.to_lowercase().contains(".gif?")
 -                    || source.to_lowercase().contains("/gif/");
+-
 -                if animate && is_gif {
 +                // Check if we should animate (GIF, WebP, or APNG with animate flag)
 +                let source_lower = source.to_lowercase();
 +                let is_animatable = source_lower.ends_with(".gif")
 +                    || source_lower.contains(".gif?")
 +                    || source_lower.contains("/gif/")
 +                    || source_lower.ends_with(".webp")
 +                    || source_lower.contains(".webp?")
 +                    || source_lower.contains("/webp/")
 +                    || source_lower.ends_with(".apng")
 +                    || source_lower.ends_with(".png")  // PNG might be APNG
 +                    || source_lower.contains(".apng?")
 +                    // Video formats
 +                    || source_lower.ends_with(".mp4")
 +                    || source_lower.ends_with(".webm")
 +                    || source_lower.ends_with(".mkv")
 +                    || source_lower.ends_with(".avi")
 +                    || source_lower.ends_with(".mov")
 +                    || source_lower.ends_with(".m4v");
++
 +                // Videos should always be animated (no sense displaying a single frame)
 +                let is_video = source_lower.ends_with(".mp4")
 +                    || source_lower.ends_with(".webm")
 +                    || source_lower.ends_with(".mkv")
 +                    || source_lower.ends_with(".avi")
 +                    || source_lower.ends_with(".mov")
 +                    || source_lower.ends_with(".m4v");
++
 +                // Auto-animate videos, or animate if flag is set for other formats
 +                let should_animate = is_video || (animate && is_animatable);
++
 +                if should_animate {
                      // Try to start animation
                      match self.start_animation(&source, scale_mode, max_fps) {
                          Ok(_) => {
+                 }
+             }
              Command::ClearCache => {
 -                // TODO: Implement cache clearing
 -                Response::ok()
 +                if let Some(ref mut cache) = self.cache {
 +                    match cache.clear() {
 +                        Ok(_) => {
 +                            tracing::info!("Cache cleared");
 +                            Response::ok()
 +                        }
 +                        Err(e) => Response::error(format!("Failed to clear cache: {}", e)),
 +                    }
 +                } else {
 +                    Response::ok() // No cache to clear
 +                }
+             }
              Command::List { source } => {
                  match self.list_source(&source) {
          self.set_wallpaper_from_source(&source, mode, shuffle)
+     }
 -    /// Start an animated GIF playback
 +    /// Start an animated image playback (GIF, WebP, APNG, or video)
      fn start_animation(&mut self, source: &str, mode: ScaleMode, max_fps: u32) -> Result<()> {
          let is_remote = source.starts_with("http://") || source.starts_with("https://");
 +        let source_lower = source.to_lowercase();
++
 +        // Detect format from extension/URL
 +        let is_webp = source_lower.ends_with(".webp")
 +            || source_lower.contains(".webp?")
 +            || source_lower.contains("/webp/");
 +        let is_apng = source_lower.ends_with(".apng")
 +            || source_lower.contains(".apng?");
 +        let is_png = source_lower.ends_with(".png");
++
 +        // Check for video formats
 +        #[cfg(feature = "video")]
 +        let is_video = {
 +            let expanded = shellexpand::tilde(source);
 +            !is_remote && is_video_file(expanded.as_ref())
 +        };
 +        #[cfg(not(feature = "video"))]
 +        let is_video = false;
++
 +        // Handle video separately (can't load into memory efficiently)
 +        #[cfg(feature = "video")]
 +        if is_video {
 +            return self.start_video_animation(source, mode, max_fps);
 +        }
 -        // Load the GIF
 -        let gif = if is_remote {
 -            tracing::info!("Fetching remote GIF: {}", source);
 -            let bytes = self.fetch_bytes(source)?;
 -            AnimatedGif::load_from_bytes(&bytes)?
 +        // Load animation data for image formats
 +        let bytes = if is_remote {
 +            tracing::info!("Fetching remote animation: {}", source);
 +            self.fetch_bytes(source)?
          } else {
              let expanded = shellexpand::tilde(source);
 -            AnimatedGif::load(expanded.as_ref())?
 +            std::fs::read(expanded.as_ref())
 +                .with_context(|| format!("Failed to read: {}", source))?
          };
 -        if !gif.is_animated() {
 -            anyhow::bail!("GIF is not animated (single frame)");
 -        }
 +        // Load frames based on format - clone frames to avoid lifetime issues
 +        let (frames, frame_count, avg_fps, format_name): (Vec<AnimationFrame>, usize, f64, &str) = if is_webp {
 +            let webp = AnimatedWebP::load_from_bytes(&bytes)?;
 +            if !webp.is_animated() {
 +                anyhow::bail!("WebP is not animated (single frame)");
 +            }
 +            let fc = webp.frame_count();
 +            let fps = webp.average_fps();
 +            (webp.frames().to_vec(), fc, fps, "WebP")
 +        } else if is_apng || is_png {
 +            // Try APNG first for .png files (might be animated)
 +            match AnimatedPng::load_from_bytes(&bytes) {
 +                Ok(apng) if apng.is_animated() => {
 +                    let fc = apng.frame_count();
 +                    let fps = apng.average_fps();
 +                    (apng.frames().to_vec(), fc, fps, "APNG")
 +                }
 +                Ok(_) => {
 +                    anyhow::bail!("PNG is not animated");
 +                }
 +                Err(e) if is_apng => {
 +                    // .apng extension but failed to load as APNG
 +                    anyhow::bail!("Failed to load APNG: {}", e);
 +                }
 +                Err(_) => {
 +                    // .png extension but not an APNG, try as static
 +                    anyhow::bail!("PNG is not animated (use without --animate)");
 +                }
 +            }
 +        } else {
 +            // Default to GIF
 +            let gif = AnimatedGif::load_from_bytes(&bytes)?;
 +            if !gif.is_animated() {
 +                anyhow::bail!("GIF is not animated (single frame)");
 +            }
 +            let fc = gif.frame_count();
 +            let fps = gif.average_fps();
 +            (gif.frames().to_vec(), fc, fps, "GIF")
 +        };
 -        // Pre-scale all frames
 +        // Suppress warning when video feature is disabled
 +        let _ = is_video;
++
 +        // Create animation renderer
 +        let renderer = AnimationRenderer::new(&self.conn)?;
          let (width, height) = self.conn.screen_dimensions();
 -        let scaled_frames: Vec<image::RgbaImage> = gif
 -            .frames()
 -            .iter()
 -            .map(|frame| scale_image(&frame.image, width as u32, height as u32, mode))
 -            .collect();
++
 +        tracing::info!(
 +            "Animation loaded: {} frames, {:.1} FPS ({})",
 +            frame_count,
 +            avg_fps,
 +            format_name
 +        );
++
 +        self.animation = Some(ActiveAnimation::from_frames(
 +            &frames,
 +            renderer,
 +            max_fps,
 +            mode,
 +            source.to_string(),
 +            width as u32,
 +            height as u32,
 +        ));
++
 +        Ok(())
 +    }
++
 +    /// Start video animation playback
 +    #[cfg(feature = "video")]
 +    fn start_video_animation(&mut self, source: &str, mode: ScaleMode, max_fps: u32) -> Result<()> {
 +        let expanded = shellexpand::tilde(source);
 +        let path = std::path::Path::new(expanded.as_ref());
++
 +        tracing::info!("Opening video: {}", path.display());
++
 +        let mut decoder = VideoDecoder::open(path)?;
 +        let info = decoder.info().clone();
 +        let frame_delay = decoder.frame_delay();
++
 +        tracing::info!(
 +            "Video: {}x{}, {:.1} FPS, {:.1}s duration, ~{} frames ({})",
 +            info.width,
 +            info.height,
 +            info.frame_rate,
 +            info.duration,
 +            info.frame_count,
 +            info.codec
 +        );
++
 +        // Limit frames for memory efficiency (max ~30 seconds at target fps)
 +        let max_frames = (30.0 * info.frame_rate.min(max_fps as f64)) as usize;
 +        let frame_limit = max_frames.max(100).min(info.frame_count);
++
 +        // Extract frames
 +        let mut frames = Vec::with_capacity(frame_limit);
 +        while let Some(decoded) = decoder.next_frame()? {
 +            frames.push(AnimationFrame {
 +                image: decoded.image,
 +                delay: frame_delay,
 +            });
++
 +            if frames.len() >= frame_limit {
 +                tracing::debug!("Reached frame limit ({}), stopping decode", frame_limit);
 +                break;
 +            }
 +        }
++
 +        if frames.is_empty() {
 +            anyhow::bail!("Video has no decodable frames");
 +        }
++
 +        let frame_count = frames.len();
 +        let avg_fps = info.frame_rate;
          // Create animation renderer
          let renderer = AnimationRenderer::new(&self.conn)?;
 +        let (width, height) = self.conn.screen_dimensions();
          tracing::info!(
 -            "Animation loaded: {} frames, {:.1} FPS",
 -            gif.frame_count(),
 -            gif.average_fps()
 +            "Video loaded: {} frames, {:.1} FPS",
 +            frame_count,
 +            avg_fps
          );
 -        self.animation = Some(ActiveAnimation {
 -            gif,
 -            scaled_frames,
 +        self.animation = Some(ActiveAnimation::from_frames(
 +            &frames,
              renderer,
 -            current_frame: 0,
              max_fps,
 -            scale_mode: mode,
 -            source: source.to_string(),
 -        });
 +            mode,
 +            source.to_string(),
 +            width as u32,
 +            height as u32,
 +        ));
          Ok(())
+     }
 -    /// Fetch raw bytes from a URL
 -    fn fetch_bytes(&self, url: &str) -> Result<Vec<u8>> {
 +    /// Fetch raw bytes from a URL (with caching)
 +    fn fetch_bytes(&mut self, url: &str) -> Result<Vec<u8>> {
 +        // Check cache first
 +        if let Some(ref mut cache) = self.cache {
 +            if let Some(cached_path) = cache.get(url) {
 +                tracing::debug!("Cache hit: {}", url);
 +                return std::fs::read(&cached_path)
 +                    .context("Failed to read cached file");
 +            }
 +        }
++
 +        // Fetch from network
 +        tracing::debug!("Cache miss, fetching: {}", url);
          let client = reqwest::blocking::Client::builder()
              .user_agent("garbg/0.1")
              .build()?;
              anyhow::bail!("HTTP error {}: {}", status, url);
+         }
 -        Ok(response.bytes()?.to_vec())
 +        // Get ETag for conditional requests
 +        let etag = response.headers()
 +            .get("etag")
 +            .and_then(|v| v.to_str().ok())
 +            .map(String::from);
++
 +        let bytes = response.bytes()?.to_vec();
++
 +        // Store in cache
 +        if let Some(ref mut cache) = self.cache {
 +            if let Err(e) = cache.store(url, &bytes, etag) {
 +                tracing::warn!("Failed to cache {}: {}", url, e);
 +            } else {
 +                tracing::debug!("Cached: {}", url);
 +            }
 +        }
++
 +        Ok(bytes)
+     }
      /// Set wallpaper with full options (used by IPC Set command)
          Ok(())
+     }
 -    /// Fetch image from URL
 -    fn fetch_image(&self, url: &str) -> Result<image::RgbaImage> {
 -        let client = reqwest::blocking::Client::builder()
 -            .user_agent("garbg/0.1")
 -            .build()?;
+-
 -        let response = client.get(url).send()?;
 -        let status = response.status();
+-
 -        if !status.is_success() {
 -            anyhow::bail!("HTTP error {}: {}", status, url);
 -        }
+-
 -        let bytes = response.bytes()?;
 +    /// Fetch image from URL (with caching)
 +    fn fetch_image(&mut self, url: &str) -> Result<image::RgbaImage> {
 +        // Use cached bytes
 +        let bytes = self.fetch_bytes(url)?;
          ImageLoader::load_bytes(&bytes, None)
+     }
          Ok(images)
+     }
+ }
++
 +/// RAII guard for PID file cleanup
 +///
 +/// Removes the PID file when dropped, ensuring cleanup even on panic.
 +struct PidFileGuard;
++
 +impl Drop for PidFileGuard {
 +    fn drop(&mut self) {
 +        if let Err(e) = pid::remove_pid_file() {
 +            tracing::warn!("Failed to remove PID file on shutdown: {}", e);
 +        } else {
 +            tracing::debug!("PID file removed on shutdown");
 +        }
 +    }
 +}

garbg/src/ipc/gar_client.rsmodified

  //! Client for gar window manager's IPC
  use anyhow::{Context, Result};
 -use serde::{Deserialize, Serialize};
 +use serde::Deserialize;
  use std::path::PathBuf;
  use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
  use tokio::net::UnixStream;
  /// Client for communicating with gar window manager
  pub struct GarIpcClient {
 -    stream: UnixStream,
 +    reader: BufReader<tokio::net::unix::OwnedReadHalf>,
 +    writer: tokio::net::unix::OwnedWriteHalf,
+ }
  impl GarIpcClient {
              .await
              .with_context(|| format!("Failed to connect to gar at {}", path.display()))?;
 -        Ok(Self { stream })
 +        let (read_half, write_half) = stream.into_split();
 +        let reader = BufReader::new(read_half);
++
 +        Ok(Self { reader, writer: write_half })
+     }
      /// Get gar's socket path
          });
          let json = serde_json::to_string(&cmd)?;
 -        self.stream.write_all(json.as_bytes()).await?;
 -        self.stream.write_all(b"\n").await?;
 +        self.writer.write_all(json.as_bytes()).await?;
 +        self.writer.write_all(b"\n").await?;
 -        Ok(())
 +        // Read the response (success or error)
 +        let mut line = String::new();
 +        self.reader.read_line(&mut line).await?;
++
 +        // Check for success
 +        let response: serde_json::Value = serde_json::from_str(&line)
 +            .context("Failed to parse subscribe response")?;
++
 +        if response.get("success") == Some(&serde_json::Value::Bool(true)) {
 +            Ok(())
 +        } else {
 +            let err = response.get("error")
 +                .and_then(|e| e.as_str())
 +                .unwrap_or("Unknown error");
 +            anyhow::bail!("Subscribe failed: {}", err);
 +        }
+     }
      /// Read the next event from gar
      pub async fn read_event(&mut self) -> Result<GarEvent> {
 -        let mut reader = BufReader::new(&mut self.stream);
          let mut line = String::new();
 -        reader.read_line(&mut line).await?;
 +        self.reader.read_line(&mut line).await?;
++
 +        if line.is_empty() {
 +            anyhow::bail!("Connection closed");
 +        }
 -        let event: GarEvent = serde_json::from_str(&line)
 -            .context("Failed to parse gar event")?;
 +        // gar uses { "event": "name", "data": {...} } format
 +        let raw: RawGarEvent = serde_json::from_str(&line)
 +            .with_context(|| format!("Failed to parse gar event: {}", line.trim()))?;
 -        Ok(event)
 +        Ok(raw.into())
+     }
+ }
 +/// Raw event format from gar: { "event": "name", "data": {...} }
 +#[derive(Debug, Deserialize)]
 +struct RawGarEvent {
 +    event: String,
 +    #[serde(default)]
 +    data: serde_json::Value,
 +}
++
  /// Events from gar window manager
 -#[derive(Debug, Clone, Serialize, Deserialize)]
 -#[serde(tag = "event", rename_all = "snake_case")]
 +#[derive(Debug, Clone)]
  pub enum GarEvent {
      /// Workspace changed
      Workspace {
      },
      /// Unknown event (for forward compatibility)
 -    #[serde(other)]
      Unknown,
+ }
++
 +impl From<RawGarEvent> for GarEvent {
 +    fn from(raw: RawGarEvent) -> Self {
 +        match raw.event.as_str() {
 +            "workspace" => {
 +                let current = raw.data.get("current")
 +                    .and_then(|v| v.as_u64())
 +                    .unwrap_or(1) as usize;
 +                let previous = raw.data.get("previous")
 +                    .and_then(|v| v.as_u64())
 +                    .unwrap_or(0) as usize;
 +                GarEvent::Workspace { current, previous }
 +            }
 +            "monitor" => {
 +                let name = raw.data.get("name")
 +                    .and_then(|v| v.as_str())
 +                    .unwrap_or("unknown")
 +                    .to_string();
 +                let action = raw.data.get("action")
 +                    .and_then(|v| v.as_str())
 +                    .unwrap_or("unknown")
 +                    .to_string();
 +                GarEvent::Monitor { name, action }
 +            }
 +            "focus" => {
 +                let window_id = raw.data.get("window_id")
 +                    .and_then(|v| v.as_u64())
 +                    .unwrap_or(0) as u32;
 +                let workspace = raw.data.get("workspace")
 +                    .and_then(|v| v.as_u64())
 +                    .unwrap_or(1) as usize;
 +                GarEvent::Focus { window_id, workspace }
 +            }
 +            _ => GarEvent::Unknown,
 +        }
 +    }
 +}

garbg/src/ipc/server.rsmodified

  use std::path::PathBuf;
  use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
  use tokio::net::{UnixListener, UnixStream};
 -use tokio::sync::mpsc;
  use super::protocol::{Command, Event, Response};

garbg/src/main.rsmodified

  use anyhow::Result;
  use clap::{Parser, Subcommand};
 +use indicatif::{ProgressBar, ProgressStyle};
  use rand::seq::SliceRandom;
  use std::time::Duration;
  use tracing_subscriber::{fmt, prelude::*, EnvFilter};
 +use garbg::ipc::{Command, Response};
  use garbg::state::{detect_source_type, PlaylistState};
  #[derive(Parser)]
      Ok(())
+ }
 +/// Send a command to the daemon with a spinner
 +fn send_with_spinner(cmd: &Command, message: &str) -> Result<Response> {
 +    use garbg::ipc::send_command_blocking;
++
 +    let spinner = ProgressBar::new_spinner();
 +    spinner.set_style(
 +        ProgressStyle::default_spinner()
 +            .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
 +            .template("{spinner:.cyan} {msg}")
 +            .unwrap()
 +    );
 +    spinner.set_message(message.to_string());
 +    spinner.enable_steady_tick(Duration::from_millis(80));
++
 +    let response = send_command_blocking(cmd)?;
++
 +    spinner.finish_and_clear();
 +    Ok(response)
 +}
++
  fn set_wallpaper(
      source: &str,
      mode: &str,
      max_fps: u32,
  ) -> Result<()> {
      use garbg::config::ScaleMode;
 -    use garbg::ipc::{is_daemon_running, send_command_blocking, Command};
 +    use garbg::ipc::is_daemon_running;
      let scale_mode: ScaleMode = mode.parse()?;
              max_fps,
          };
 -        let response = send_command_blocking(&cmd)?;
 +        let response = send_with_spinner(&cmd, "Loading wallpaper...")?;
          if response.success {
              if let Some(secs) = interval_secs {
      tracing::info!("Setting wallpaper: {}", source);
 -    // Check if source is a GIF file (by extension or URL path)
 -    let is_gif = source.to_lowercase().ends_with(".gif")
 -        || source.to_lowercase().contains(".gif?")  // URL with query params
 -        || source.to_lowercase().contains("/gif/"); // Giphy-style URLs
 +    // Check if source is animatable (GIF, WebP, or APNG)
 +    let source_lower = source.to_lowercase();
 +    let is_gif = source_lower.ends_with(".gif")
 +        || source_lower.contains(".gif?")  // URL with query params
 +        || source_lower.contains("/gif/"); // Giphy-style URLs
 +    let is_webp = source_lower.ends_with(".webp")
 +        || source_lower.contains(".webp?")
 +        || source_lower.contains("/webp/");
 +    let is_apng = source_lower.ends_with(".apng")
 +        || source_lower.contains(".apng?")
 +        || source_lower.ends_with(".png");  // PNG might be APNG
      let is_remote = source.starts_with("http://") || source.starts_with("https://");
 +    // For animated WebP/APNG, recommend using daemon (GIF works standalone)
 +    if (is_webp || is_apng) && animate {
 +        // WebP/APNG animation is only supported via daemon
 +        use garbg::ipc::is_daemon_running;
 +        if !is_daemon_running() {
 +            let format = if is_webp { "WebP" } else { "APNG" };
 +            eprintln!("Note: Animated {} requires daemon mode.", format);
 +            eprintln!("      Start daemon first: garbg daemon -d");
 +            eprintln!("      Then run: garbg set {} --animate", source);
 +            anyhow::bail!("Animated {} requires daemon mode", format);
 +        }
 +        // Daemon is running - delegate (already done in set_wallpaper)
 +    }
++
      // If it's a GIF and animation is requested, try to load as animated
      if is_gif && animate {
          // Load GIF data (from file or URL)

garbg/src/media/apng.rsadded

 +//! Animated PNG (APNG) decoder with frame-by-frame access
 +//!
 +//! Provides frame extraction and timing information for animated PNG images.
++
 +use anyhow::{Context, Result};
 +use image::codecs::png::PngDecoder;
 +use image::{AnimationDecoder, Frame};
 +use std::fs;
 +use std::io::Cursor;
 +use std::path::Path;
 +use std::time::Duration;
++
 +use super::gif::AnimationFrame;
++
 +/// Decoded animated PNG with all frames
 +pub struct AnimatedPng {
 +    /// All frames in order
 +    frames: Vec<AnimationFrame>,
 +    /// Current frame index
 +    current_index: usize,
 +    /// Whether to loop forever
 +    pub loops: bool,
 +    /// Total duration of one loop
 +    pub total_duration: Duration,
 +}
++
 +impl AnimatedPng {
 +    /// Load an animated PNG from a file path
 +    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
 +        let path = path.as_ref();
 +        let data = fs::read(path)
 +            .with_context(|| format!("Failed to read PNG: {}", path.display()))?;
++
 +        Self::load_from_bytes(&data)
 +    }
++
 +    /// Load an animated PNG from bytes
 +    pub fn load_from_bytes(data: &[u8]) -> Result<Self> {
 +        let cursor = Cursor::new(data);
 +        let decoder = PngDecoder::new(cursor)
 +            .context("Failed to create PNG decoder")?;
++
 +        // Check if this is an animated PNG
 +        if !decoder.is_apng().unwrap_or(false) {
 +            anyhow::bail!("PNG is not animated (APNG)");
 +        }
++
 +        let raw_frames = decoder.apng()
 +            .context("Failed to get APNG decoder")?
 +            .into_frames();
++
 +        let mut frames = Vec::new();
 +        let mut total_duration = Duration::ZERO;
++
 +        for frame_result in raw_frames {
 +            let frame: Frame = frame_result.context("Failed to decode APNG frame")?;
 +            let delay = frame_delay_to_duration(&frame);
++
 +            // APNG with 0 delay means "as fast as possible"
 +            // Default to 100ms (10 fps) for reasonable playback
 +            let delay = if delay.is_zero() {
 +                Duration::from_millis(100)
 +            } else {
 +                delay
 +            };
++
 +            total_duration += delay;
++
 +            frames.push(AnimationFrame {
 +                image: frame.into_buffer(),
 +                delay,
 +            });
 +        }
++
 +        if frames.is_empty() {
 +            anyhow::bail!("APNG contains no frames");
 +        }
++
 +        Ok(Self {
 +            frames,
 +            current_index: 0,
 +            loops: true,
 +            total_duration,
 +        })
 +    }
++
 +    /// Get the number of frames
 +    pub fn frame_count(&self) -> usize {
 +        self.frames.len()
 +    }
++
 +    /// Check if this is actually animated (more than one frame)
 +    pub fn is_animated(&self) -> bool {
 +        self.frames.len() > 1
 +    }
++
 +    /// Get the current frame
 +    pub fn current_frame(&self) -> &AnimationFrame {
 +        &self.frames[self.current_index]
 +    }
++
 +    /// Get a specific frame by index
 +    pub fn frame(&self, index: usize) -> Option<&AnimationFrame> {
 +        self.frames.get(index)
 +    }
++
 +    /// Get the current frame index
 +    pub fn current_index(&self) -> usize {
 +        self.current_index
 +    }
++
 +    /// Advance to the next frame, returning true if we looped
 +    pub fn advance(&mut self) -> bool {
 +        self.current_index += 1;
 +        if self.current_index >= self.frames.len() {
 +            self.current_index = 0;
 +            true // Looped
 +        } else {
 +            false
 +        }
 +    }
++
 +    /// Go back to the previous frame
 +    pub fn rewind(&mut self) -> bool {
 +        if self.current_index == 0 {
 +            self.current_index = self.frames.len() - 1;
 +            true // Looped
 +        } else {
 +            self.current_index -= 1;
 +            false
 +        }
 +    }
++
 +    /// Reset to the first frame
 +    pub fn reset(&mut self) {
 +        self.current_index = 0;
 +    }
++
 +    /// Get all frames as a slice
 +    pub fn frames(&self) -> &[AnimationFrame] {
 +        &self.frames
 +    }
++
 +    /// Get average FPS
 +    pub fn average_fps(&self) -> f64 {
 +        if self.total_duration.is_zero() {
 +            return 0.0;
 +        }
 +        self.frames.len() as f64 / self.total_duration.as_secs_f64()
 +    }
++
 +    /// Get dimensions (width, height) from first frame
 +    pub fn dimensions(&self) -> (u32, u32) {
 +        let first = &self.frames[0].image;
 +        (first.width(), first.height())
 +    }
 +}
++
 +/// Convert frame delay ratio to Duration
 +fn frame_delay_to_duration(frame: &Frame) -> Duration {
 +    let (numerator, denominator) = frame.delay().numer_denom_ms();
 +    if denominator == 0 {
 +        Duration::ZERO
 +    } else {
 +        Duration::from_millis((numerator as u64 * 1000) / denominator as u64)
 +    }
 +}
++
 +/// Check if a file is an animated PNG (APNG)
 +pub fn is_animated_png<P: AsRef<Path>>(path: P) -> bool {
 +    let path = path.as_ref();
++
 +    // Quick extension check first
 +    let ext = path
 +        .extension()
 +        .and_then(|e| e.to_str())
 +        .map(|e| e.to_lowercase());
++
 +    if ext.as_deref() != Some("png") && ext.as_deref() != Some("apng") {
 +        return false;
 +    }
++
 +    // Try to load and check for animation
 +    match AnimatedPng::load(path) {
 +        Ok(apng) => apng.is_animated(),
 +        Err(_) => false,
 +    }
 +}
++
 +/// Check if bytes represent an animated PNG
 +pub fn is_animated_png_bytes(data: &[u8]) -> bool {
 +    match AnimatedPng::load_from_bytes(data) {
 +        Ok(apng) => apng.is_animated(),
 +        Err(_) => false,
 +    }
 +}

garbg/src/media/frame_buffer.rsadded

 +//! Frame pre-rendering ring buffer
 +//!
 +//! Provides memory-efficient frame buffering for animations and video playback.
 +//! Uses a producer-consumer pattern with frame recycling.
++
 +use crossbeam_channel::{bounded, Receiver, Sender, TryRecvError};
 +use image::RgbaImage;
 +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 +use std::sync::Arc;
 +use std::thread;
 +use std::time::Duration;
++
 +/// A single frame in the buffer
 +pub struct BufferedFrame {
 +    /// The frame image data
 +    pub image: RgbaImage,
 +    /// Frame index in the source
 +    pub index: usize,
 +    /// Frame delay (time until next frame)
 +    pub delay: Duration,
 +}
++
 +impl BufferedFrame {
 +    /// Create a new buffered frame
 +    pub fn new(image: RgbaImage, index: usize, delay: Duration) -> Self {
 +        Self { image, index, delay }
 +    }
 +}
++
 +/// Statistics about the frame buffer
 +#[derive(Debug, Clone)]
 +pub struct FrameBufferStats {
 +    /// Number of frames currently in buffer
 +    pub buffered: usize,
 +    /// Total frames produced
 +    pub produced: usize,
 +    /// Total frames consumed
 +    pub consumed: usize,
 +    /// Number of frames recycled
 +    pub recycled: usize,
 +    /// Whether the producer is done
 +    pub producer_done: bool,
 +}
++
 +/// Ring buffer for pre-rendered frames
 +///
 +/// Uses a producer-consumer pattern where:
 +/// - Producer thread decodes frames ahead of time
 +/// - Consumer thread displays frames
 +/// - Empty frame slots are recycled back to producer
 +pub struct FrameRingBuffer {
 +    /// Channel for ready frames (producer -> consumer)
 +    ready_frames: Receiver<BufferedFrame>,
 +    /// Channel for recycled frames (consumer -> producer)
 +    recycle_tx: Sender<RgbaImage>,
 +    /// Whether the producer has finished
 +    producer_done: Arc<AtomicBool>,
 +    /// Number of frames currently buffered
 +    buffered_count: Arc<AtomicUsize>,
 +    /// Statistics
 +    consumed_count: usize,
 +}
++
 +impl FrameRingBuffer {
 +    /// Maximum number of frames to buffer ahead
 +    pub const DEFAULT_BUFFER_SIZE: usize = 30;
++
 +    /// Create a new frame ring buffer with a producer function
 +    ///
 +    /// The producer function should:
 +    /// 1. Try to receive recycled frames from `recycle_rx`
 +    /// 2. If no recycled frame, allocate a new one
 +    /// 3. Fill the frame with decoded data
 +    /// 4. Send via `frame_tx`
 +    /// 5. Return `None` when done producing frames
 +    pub fn new<F>(
 +        buffer_size: usize,
 +        frame_width: u32,
 +        frame_height: u32,
 +        mut producer: F,
 +    ) -> Self
 +    where
 +        F: FnMut(&Receiver<RgbaImage>, &Sender<BufferedFrame>, usize) -> bool + Send + 'static,
 +    {
 +        let (frame_tx, frame_rx) = bounded::<BufferedFrame>(buffer_size);
 +        let (recycle_tx, recycle_rx) = bounded::<RgbaImage>(buffer_size);
 +        let producer_done = Arc::new(AtomicBool::new(false));
 +        let producer_done_clone = Arc::clone(&producer_done);
 +        let buffered_count = Arc::new(AtomicUsize::new(0));
 +        let buffered_count_clone = Arc::clone(&buffered_count);
++
 +        // Pre-allocate recycled frames
 +        for _ in 0..buffer_size {
 +            let frame = RgbaImage::new(frame_width, frame_height);
 +            let _ = recycle_tx.try_send(frame);
 +        }
++
 +        // Spawn producer thread
 +        thread::spawn(move || {
 +            let mut frame_index = 0;
 +            loop {
 +                let should_continue = producer(&recycle_rx, &frame_tx, frame_index);
 +                if !should_continue {
 +                    break;
 +                }
 +                buffered_count_clone.fetch_add(1, Ordering::Relaxed);
 +                frame_index += 1;
 +            }
 +            producer_done_clone.store(true, Ordering::Release);
 +            tracing::debug!("Frame producer finished at index {}", frame_index);
 +        });
++
 +        Self {
 +            ready_frames: frame_rx,
 +            recycle_tx,
 +            producer_done,
 +            buffered_count,
 +            consumed_count: 0,
 +        }
 +    }
++
 +    /// Try to get the next frame (non-blocking)
 +    ///
 +    /// Returns `None` if no frame is available yet.
 +    pub fn try_next(&mut self) -> Option<BufferedFrame> {
 +        match self.ready_frames.try_recv() {
 +            Ok(frame) => {
 +                self.buffered_count.fetch_sub(1, Ordering::Relaxed);
 +                self.consumed_count += 1;
 +                Some(frame)
 +            }
 +            Err(TryRecvError::Empty) => None,
 +            Err(TryRecvError::Disconnected) => None,
 +        }
 +    }
++
 +    /// Get the next frame (blocking with timeout)
 +    ///
 +    /// Returns `None` if timeout is reached or producer is done.
 +    pub fn next_timeout(&mut self, timeout: Duration) -> Option<BufferedFrame> {
 +        match self.ready_frames.recv_timeout(timeout) {
 +            Ok(frame) => {
 +                self.buffered_count.fetch_sub(1, Ordering::Relaxed);
 +                self.consumed_count += 1;
 +                Some(frame)
 +            }
 +            Err(_) => None,
 +        }
 +    }
++
 +    /// Get the next frame (blocking)
 +    ///
 +    /// Returns `None` only when producer is done and buffer is empty.
 +    pub fn next(&mut self) -> Option<BufferedFrame> {
 +        match self.ready_frames.recv() {
 +            Ok(frame) => {
 +                self.buffered_count.fetch_sub(1, Ordering::Relaxed);
 +                self.consumed_count += 1;
 +                Some(frame)
 +            }
 +            Err(_) => None,
 +        }
 +    }
++
 +    /// Recycle a frame's image buffer back to the producer
 +    ///
 +    /// This allows the producer to reuse the memory allocation.
 +    pub fn recycle(&self, image: RgbaImage) {
 +        let _ = self.recycle_tx.try_send(image);
 +    }
++
 +    /// Check if the producer has finished
 +    pub fn is_producer_done(&self) -> bool {
 +        self.producer_done.load(Ordering::Acquire)
 +    }
++
 +    /// Check if the buffer is empty and producer is done
 +    pub fn is_exhausted(&self) -> bool {
 +        self.is_producer_done() && self.buffered_count.load(Ordering::Relaxed) == 0
 +    }
++
 +    /// Get current buffer statistics
 +    pub fn stats(&self) -> FrameBufferStats {
 +        FrameBufferStats {
 +            buffered: self.buffered_count.load(Ordering::Relaxed),
 +            produced: self.consumed_count + self.buffered_count.load(Ordering::Relaxed),
 +            consumed: self.consumed_count,
 +            recycled: 0, // Would need additional tracking
 +            producer_done: self.is_producer_done(),
 +        }
 +    }
++
 +    /// Number of frames currently buffered
 +    pub fn buffered_count(&self) -> usize {
 +        self.buffered_count.load(Ordering::Relaxed)
 +    }
 +}
++
 +/// Simple looping frame buffer for finite animations (GIF, WebP)
 +///
 +/// Pre-scales all frames and cycles through them.
 +pub struct LoopingFrameBuffer {
 +    /// All frames (pre-scaled)
 +    frames: Vec<BufferedFrame>,
 +    /// Current frame index
 +    current: usize,
 +}
++
 +impl LoopingFrameBuffer {
 +    /// Create from existing frames
 +    pub fn new(frames: Vec<BufferedFrame>) -> Self {
 +        Self { frames, current: 0 }
 +    }
++
 +    /// Get the current frame
 +    pub fn current(&self) -> Option<&BufferedFrame> {
 +        self.frames.get(self.current)
 +    }
++
 +    /// Advance to the next frame, looping if necessary
 +    ///
 +    /// Returns true if we looped back to the start.
 +    pub fn advance(&mut self) -> bool {
 +        self.current += 1;
 +        if self.current >= self.frames.len() {
 +            self.current = 0;
 +            true
 +        } else {
 +            false
 +        }
 +    }
++
 +    /// Go to a specific frame index
 +    pub fn seek(&mut self, index: usize) {
 +        self.current = index % self.frames.len();
 +    }
++
 +    /// Get the number of frames
 +    pub fn len(&self) -> usize {
 +        self.frames.len()
 +    }
++
 +    /// Check if buffer is empty
 +    pub fn is_empty(&self) -> bool {
 +        self.frames.is_empty()
 +    }
++
 +    /// Get the current frame index
 +    pub fn current_index(&self) -> usize {
 +        self.current
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_looping_buffer() {
 +        let frames = vec![
 +            BufferedFrame::new(RgbaImage::new(1, 1), 0, Duration::from_millis(100)),
 +            BufferedFrame::new(RgbaImage::new(1, 1), 1, Duration::from_millis(100)),
 +            BufferedFrame::new(RgbaImage::new(1, 1), 2, Duration::from_millis(100)),
 +        ];
++
 +        let mut buffer = LoopingFrameBuffer::new(frames);
++
 +        assert_eq!(buffer.current_index(), 0);
 +        assert!(!buffer.advance()); // 0 -> 1
 +        assert_eq!(buffer.current_index(), 1);
 +        assert!(!buffer.advance()); // 1 -> 2
 +        assert_eq!(buffer.current_index(), 2);
 +        assert!(buffer.advance()); // 2 -> 0 (looped)
 +        assert_eq!(buffer.current_index(), 0);
 +    }
 +}

garbg/src/media/loader.rsmodified

  //! Image loading and format detection
  use anyhow::{Context, Result};
 -use image::{DynamicImage, ImageFormat, RgbaImage};
 +use image::{ImageFormat, RgbaImage};
  use std::fs;
  use std::path::Path;

garbg/src/media/mod.rsmodified

  mod loader;
  mod scaler;
  mod gif;
 +mod webp;
 +mod apng;
 +mod frame_buffer;
++
 +#[cfg(feature = "video")]
 +mod video;
  pub use loader::ImageLoader;
  pub use scaler::scale_image;
  pub use gif::{AnimatedGif, AnimationFrame, is_animated_gif};
 +pub use webp::{AnimatedWebP, is_animated_webp, is_animated_webp_bytes};
 +pub use apng::{AnimatedPng, is_animated_png, is_animated_png_bytes};
 +pub use frame_buffer::{BufferedFrame, FrameRingBuffer, LoopingFrameBuffer, FrameBufferStats};
++
 +#[cfg(feature = "video")]
 +pub use video::{VideoDecoder, VideoInfo, DecodedFrame, is_video_file, init as init_video};
  // Re-export ScaleMode from config for convenience
  pub use crate::config::ScaleMode;

garbg/src/media/video.rsadded

 +//! Video decoding for video wallpapers
 +//!
 +//! Provides frame-by-frame video decoding using ffmpeg.
 +//! Requires the `video` feature and system ffmpeg libraries.
++
 +#![cfg(feature = "video")]
++
 +use anyhow::{Context, Result};
 +use ffmpeg_next as ffmpeg;
 +use ffmpeg_next::format::{input, Pixel};
 +use ffmpeg_next::media::Type;
 +use ffmpeg_next::software::scaling::{context::Context as ScalerContext, flag::Flags};
 +use ffmpeg_next::util::frame::video::Video as VideoFrame;
 +use image::RgbaImage;
 +use std::path::Path;
 +use std::sync::Once;
 +use std::time::Duration;
++
 +static FFMPEG_INIT: Once = Once::new();
++
 +/// Initialize ffmpeg (call once at startup)
 +pub fn init() -> Result<()> {
 +    let mut init_result = Ok(());
 +    FFMPEG_INIT.call_once(|| {
 +        if let Err(e) = ffmpeg::init() {
 +            init_result = Err(anyhow::anyhow!("Failed to initialize ffmpeg: {}", e));
 +        }
 +    });
 +    init_result
 +}
++
 +/// Information about a video file
 +#[derive(Debug, Clone)]
 +pub struct VideoInfo {
 +    /// Video width in pixels
 +    pub width: u32,
 +    /// Video height in pixels
 +    pub height: u32,
 +    /// Duration in seconds
 +    pub duration: f64,
 +    /// Frame rate (FPS)
 +    pub frame_rate: f64,
 +    /// Estimated total frames
 +    pub frame_count: usize,
 +    /// Video codec name
 +    pub codec: String,
 +}
++
 +/// A decoded video frame
 +pub struct DecodedFrame {
 +    /// Frame image data (RGBA)
 +    pub image: RgbaImage,
 +    /// Presentation timestamp (seconds from start)
 +    pub pts: f64,
 +    /// Frame index
 +    pub index: usize,
 +}
++
 +/// Video decoder for extracting frames
 +pub struct VideoDecoder {
 +    /// Input context
 +    input: ffmpeg::format::context::Input,
 +    /// Video stream index
 +    stream_index: usize,
 +    /// Decoder
 +    decoder: ffmpeg::decoder::Video,
 +    /// Scaler for format conversion
 +    scaler: ScalerContext,
 +    /// Video info
 +    info: VideoInfo,
 +    /// Current frame index
 +    frame_index: usize,
 +    /// Time base for PTS conversion
 +    time_base: f64,
 +}
++
 +impl VideoDecoder {
 +    /// Open a video file for decoding
 +    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
 +        init()?;
++
 +        let path = path.as_ref();
 +        let input = input(&path)
 +            .with_context(|| format!("Failed to open video: {}", path.display()))?;
++
 +        Self::from_input(input)
 +    }
++
 +    /// Open a video from bytes (writes to temp file)
 +    pub fn open_bytes(data: &[u8]) -> Result<Self> {
 +        init()?;
++
 +        // ffmpeg-next doesn't support reading from memory directly,
 +        // so we write to a temp file
 +        let temp_dir = std::env::temp_dir();
 +        let temp_path = temp_dir.join(format!("garbg_video_{}.mp4", std::process::id()));
 +        std::fs::write(&temp_path, data)
 +            .context("Failed to write video to temp file")?;
++
 +        let result = Self::open(&temp_path);
++
 +        // Clean up temp file
 +        let _ = std::fs::remove_file(&temp_path);
++
 +        result
 +    }
++
 +    /// Create decoder from an open input context
 +    fn from_input(input: ffmpeg::format::context::Input) -> Result<Self> {
 +        // Find the best video stream
 +        let stream = input
 +            .streams()
 +            .best(Type::Video)
 +            .context("No video stream found")?;
++
 +        let stream_index = stream.index();
 +        let time_base = stream.time_base();
++
 +        // Get codec parameters
 +        let codec_params = stream.parameters();
 +        let codec = ffmpeg::codec::context::Context::from_parameters(codec_params)
 +            .context("Failed to create codec context")?;
++
 +        let decoder = codec.decoder().video()
 +            .context("Failed to create video decoder")?;
++
 +        let width = decoder.width();
 +        let height = decoder.height();
++
 +        // Create scaler to convert to RGBA
 +        let scaler = ScalerContext::get(
 +            decoder.format(),
 +            width,
 +            height,
 +            Pixel::RGBA,
 +            width,
 +            height,
 +            Flags::BILINEAR,
 +        ).context("Failed to create video scaler")?;
++
 +        // Calculate video info
 +        let duration = input.duration() as f64 / ffmpeg::ffi::AV_TIME_BASE as f64;
 +        let frame_rate = stream.avg_frame_rate();
 +        let fps = if frame_rate.denominator() != 0 {
 +            frame_rate.numerator() as f64 / frame_rate.denominator() as f64
 +        } else {
 +            30.0 // Default
 +        };
++
 +        let codec_name = decoder.codec()
 +            .map(|c| c.name().to_string())
 +            .unwrap_or_else(|| "unknown".to_string());
++
 +        let info = VideoInfo {
 +            width,
 +            height,
 +            duration,
 +            frame_rate: fps,
 +            frame_count: (duration * fps) as usize,
 +            codec: codec_name,
 +        };
++
 +        Ok(Self {
 +            input,
 +            stream_index,
 +            decoder,
 +            scaler,
 +            info,
 +            frame_index: 0,
 +            time_base: time_base.numerator() as f64 / time_base.denominator() as f64,
 +        })
 +    }
++
 +    /// Get video information
 +    pub fn info(&self) -> &VideoInfo {
 +        &self.info
 +    }
++
 +    /// Get frame delay based on frame rate
 +    pub fn frame_delay(&self) -> Duration {
 +        if self.info.frame_rate > 0.0 {
 +            Duration::from_secs_f64(1.0 / self.info.frame_rate)
 +        } else {
 +            Duration::from_millis(33) // ~30 FPS default
 +        }
 +    }
++
 +    /// Decode the next frame
 +    pub fn next_frame(&mut self) -> Result<Option<DecodedFrame>> {
 +        let mut decoded = VideoFrame::empty();
++
 +        // Read packets until we get a frame
 +        for (stream, packet) in self.input.packets() {
 +            if stream.index() != self.stream_index {
 +                continue;
 +            }
++
 +            self.decoder.send_packet(&packet)
 +                .context("Failed to send packet to decoder")?;
++
 +            while self.decoder.receive_frame(&mut decoded).is_ok() {
 +                // Convert to RGBA
 +                let mut rgb_frame = VideoFrame::empty();
 +                self.scaler.run(&decoded, &mut rgb_frame)
 +                    .context("Failed to scale frame")?;
++
 +                // Convert to RgbaImage
 +                let image = frame_to_image(&rgb_frame)?;
 +                let pts = decoded.pts().unwrap_or(0) as f64 * self.time_base;
++
 +                let frame = DecodedFrame {
 +                    image,
 +                    pts,
 +                    index: self.frame_index,
 +                };
++
 +                self.frame_index += 1;
 +                return Ok(Some(frame));
 +            }
 +        }
++
 +        // Flush the decoder
 +        self.decoder.send_eof()
 +            .context("Failed to flush decoder")?;
++
 +        while self.decoder.receive_frame(&mut decoded).is_ok() {
 +            let mut rgb_frame = VideoFrame::empty();
 +            self.scaler.run(&decoded, &mut rgb_frame)
 +                .context("Failed to scale frame")?;
++
 +            let image = frame_to_image(&rgb_frame)?;
 +            let pts = decoded.pts().unwrap_or(0) as f64 * self.time_base;
++
 +            let frame = DecodedFrame {
 +                image,
 +                pts,
 +                index: self.frame_index,
 +            };
++
 +            self.frame_index += 1;
 +            return Ok(Some(frame));
 +        }
++
 +        Ok(None)
 +    }
++
 +    /// Seek to a specific time (seconds)
 +    pub fn seek(&mut self, time_secs: f64) -> Result<()> {
 +        let timestamp = (time_secs / self.time_base) as i64;
 +        self.input.seek(timestamp, ..)
 +            .context("Failed to seek in video")?;
 +        self.decoder.flush();
 +        Ok(())
 +    }
++
 +    /// Reset to the beginning of the video
 +    pub fn reset(&mut self) -> Result<()> {
 +        self.seek(0.0)?;
 +        self.frame_index = 0;
 +        Ok(())
 +    }
++
 +    /// Get current frame index
 +    pub fn current_index(&self) -> usize {
 +        self.frame_index
 +    }
 +}
++
 +/// Convert an ffmpeg video frame to an image::RgbaImage
 +fn frame_to_image(frame: &VideoFrame) -> Result<RgbaImage> {
 +    let width = frame.width();
 +    let height = frame.height();
 +    let data = frame.data(0);
 +    let linesize = frame.stride(0);
++
 +    let mut pixels = Vec::with_capacity((width * height * 4) as usize);
++
 +    for y in 0..height {
 +        let row_start = (y as usize) * linesize;
 +        let row_end = row_start + (width as usize * 4);
 +        pixels.extend_from_slice(&data[row_start..row_end]);
 +    }
++
 +    RgbaImage::from_raw(width, height, pixels)
 +        .context("Failed to create image from frame data")
 +}
++
 +/// Check if a file is a video (by extension)
 +pub fn is_video_file<P: AsRef<Path>>(path: P) -> bool {
 +    let path = path.as_ref();
 +    let ext = path
 +        .extension()
 +        .and_then(|e| e.to_str())
 +        .map(|e| e.to_lowercase());
++
 +    matches!(ext.as_deref(), Some("mp4" | "webm" | "mkv" | "avi" | "mov" | "m4v"))
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_is_video_file() {
 +        assert!(is_video_file("test.mp4"));
 +        assert!(is_video_file("test.webm"));
 +        assert!(is_video_file("test.mkv"));
 +        assert!(!is_video_file("test.png"));
 +        assert!(!is_video_file("test.gif"));
 +    }
 +}

garbg/src/media/webp.rsadded

 +//! Animated WebP decoder with frame-by-frame access
 +//!
 +//! Provides frame extraction and timing information for animated WebP images.
++
 +use anyhow::{Context, Result};
 +use image::codecs::webp::WebPDecoder;
 +use image::{AnimationDecoder, Frame};
 +use std::fs;
 +use std::io::Cursor;
 +use std::path::Path;
 +use std::time::Duration;
++
 +use super::gif::AnimationFrame;
++
 +/// Decoded animated WebP with all frames
 +pub struct AnimatedWebP {
 +    /// All frames in order
 +    frames: Vec<AnimationFrame>,
 +    /// Current frame index
 +    current_index: usize,
 +    /// Whether to loop forever
 +    pub loops: bool,
 +    /// Total duration of one loop
 +    pub total_duration: Duration,
 +}
++
 +impl AnimatedWebP {
 +    /// Load an animated WebP from a file path
 +    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
 +        let path = path.as_ref();
 +        let data = fs::read(path)
 +            .with_context(|| format!("Failed to read WebP: {}", path.display()))?;
++
 +        Self::load_from_bytes(&data)
 +    }
++
 +    /// Load an animated WebP from bytes
 +    pub fn load_from_bytes(data: &[u8]) -> Result<Self> {
 +        let cursor = Cursor::new(data);
 +        let decoder = WebPDecoder::new(cursor)
 +            .context("Failed to create WebP decoder")?;
++
 +        // Check if this is an animated WebP
 +        if !decoder.has_animation() {
 +            anyhow::bail!("WebP is not animated");
 +        }
++
 +        let raw_frames = decoder.into_frames();
 +        let mut frames = Vec::new();
 +        let mut total_duration = Duration::ZERO;
++
 +        for frame_result in raw_frames {
 +            let frame: Frame = frame_result.context("Failed to decode WebP frame")?;
 +            let delay = frame_delay_to_duration(&frame);
++
 +            // WebP with 0 delay means "as fast as possible"
 +            // Default to 100ms (10 fps) for reasonable playback
 +            let delay = if delay.is_zero() {
 +                Duration::from_millis(100)
 +            } else {
 +                delay
 +            };
++
 +            total_duration += delay;
++
 +            frames.push(AnimationFrame {
 +                image: frame.into_buffer(),
 +                delay,
 +            });
 +        }
++
 +        if frames.is_empty() {
 +            anyhow::bail!("WebP contains no frames");
 +        }
++
 +        Ok(Self {
 +            frames,
 +            current_index: 0,
 +            loops: true,
 +            total_duration,
 +        })
 +    }
++
 +    /// Get the number of frames
 +    pub fn frame_count(&self) -> usize {
 +        self.frames.len()
 +    }
++
 +    /// Check if this is actually animated (more than one frame)
 +    pub fn is_animated(&self) -> bool {
 +        self.frames.len() > 1
 +    }
++
 +    /// Get the current frame
 +    pub fn current_frame(&self) -> &AnimationFrame {
 +        &self.frames[self.current_index]
 +    }
++
 +    /// Get a specific frame by index
 +    pub fn frame(&self, index: usize) -> Option<&AnimationFrame> {
 +        self.frames.get(index)
 +    }
++
 +    /// Get the current frame index
 +    pub fn current_index(&self) -> usize {
 +        self.current_index
 +    }
++
 +    /// Advance to the next frame, returning true if we looped
 +    pub fn advance(&mut self) -> bool {
 +        self.current_index += 1;
 +        if self.current_index >= self.frames.len() {
 +            self.current_index = 0;
 +            true // Looped
 +        } else {
 +            false
 +        }
 +    }
++
 +    /// Go back to the previous frame
 +    pub fn rewind(&mut self) -> bool {
 +        if self.current_index == 0 {
 +            self.current_index = self.frames.len() - 1;
 +            true // Looped
 +        } else {
 +            self.current_index -= 1;
 +            false
 +        }
 +    }
++
 +    /// Reset to the first frame
 +    pub fn reset(&mut self) {
 +        self.current_index = 0;
 +    }
++
 +    /// Get all frames as a slice
 +    pub fn frames(&self) -> &[AnimationFrame] {
 +        &self.frames
 +    }
++
 +    /// Get average FPS
 +    pub fn average_fps(&self) -> f64 {
 +        if self.total_duration.is_zero() {
 +            return 0.0;
 +        }
 +        self.frames.len() as f64 / self.total_duration.as_secs_f64()
 +    }
++
 +    /// Get dimensions (width, height) from first frame
 +    pub fn dimensions(&self) -> (u32, u32) {
 +        let first = &self.frames[0].image;
 +        (first.width(), first.height())
 +    }
 +}
++
 +/// Convert frame delay ratio to Duration
 +fn frame_delay_to_duration(frame: &Frame) -> Duration {
 +    let (numerator, denominator) = frame.delay().numer_denom_ms();
 +    if denominator == 0 {
 +        Duration::ZERO
 +    } else {
 +        Duration::from_millis((numerator as u64 * 1000) / denominator as u64)
 +    }
 +}
++
 +/// Check if a file is an animated WebP
 +pub fn is_animated_webp<P: AsRef<Path>>(path: P) -> bool {
 +    let path = path.as_ref();
++
 +    // Quick extension check first
 +    let ext = path
 +        .extension()
 +        .and_then(|e| e.to_str())
 +        .map(|e| e.to_lowercase());
++
 +    if ext.as_deref() != Some("webp") {
 +        return false;
 +    }
++
 +    // Try to load and check for animation
 +    match AnimatedWebP::load(path) {
 +        Ok(webp) => webp.is_animated(),
 +        Err(_) => false,
 +    }
 +}
++
 +/// Check if bytes represent an animated WebP
 +pub fn is_animated_webp_bytes(data: &[u8]) -> bool {
 +    match AnimatedWebP::load_from_bytes(data) {
 +        Ok(webp) => webp.is_animated(),
 +        Err(_) => false,
 +    }
 +}

garbg/src/sources/mod.rsmodified

  //! - HTTP/HTTPS URLs
  //! - GitHub repositories
  //! - Directory indexes (Apache/nginx)
 -//! - S3-compatible storage (optional)
 +//! - S3-compatible storage (optional, requires `s3` feature)
  mod provider;
  mod file;
  mod github;
  mod directory;
 +#[cfg(feature = "s3")]
 +mod s3;
++
  pub use provider::{SourceProvider, ProviderRegistry, WallpaperEntry, MediaType, FetchedImage};
  pub use file::FileProvider;
  pub use http::HttpProvider;
  pub use github::GitHubProvider;
  pub use directory::DirectoryIndexProvider;
++
 +#[cfg(feature = "s3")]
 +pub use s3::S3Provider;

garbg/src/sources/provider.rsmodified

      fn default() -> Self {
          let mut registry = Self::new();
 -        // Register default providers
 +        // Register default providers in order of preference
 +        // GitHub must come before HTTP to handle github:// URIs
 +        registry.register(Box::new(super::GitHubProvider::new()));
 +        registry.register(Box::new(super::HttpProvider::new()));
          registry.register(Box::new(super::FileProvider::new()));
 -        // HTTP and other providers will be registered when needed
          registry
+     }
+ }
++
 +impl ProviderRegistry {
 +    /// List wallpapers from a URI using the appropriate provider
 +    pub async fn list(&self, uri: &str) -> Result<Vec<WallpaperEntry>> {
 +        let provider = self.find_provider(uri)
 +            .ok_or_else(|| anyhow::anyhow!("No provider found for URI: {}", uri))?;
++
 +        provider.list(uri).await
 +    }
++
 +    /// Fetch a wallpaper entry using the appropriate provider
 +    pub async fn fetch(&self, entry: &WallpaperEntry) -> Result<FetchedImage> {
 +        let provider = self.find_provider(&entry.uri)
 +            .ok_or_else(|| anyhow::anyhow!("No provider found for URI: {}", entry.uri))?;
++
 +        provider.fetch(entry).await
 +    }
++
 +    /// Fetch raw bytes from a URI (for cache-aware fetching)
 +    pub async fn fetch_bytes(&self, uri: &str) -> Result<Vec<u8>> {
 +        let provider = self.find_provider(uri)
 +            .ok_or_else(|| anyhow::anyhow!("No provider found for URI: {}", uri))?;
++
 +        // List to get entry info
 +        let entries = provider.list(uri).await?;
 +        let entry = entries.first()
 +            .ok_or_else(|| anyhow::anyhow!("No wallpapers found at: {}", uri))?;
++
 +        // Fetch the image
 +        let fetched = provider.fetch(entry).await?;
++
 +        // For now, encode back to PNG bytes - TODO: return raw bytes from provider
 +        let mut bytes = Vec::new();
 +        let mut cursor = std::io::Cursor::new(&mut bytes);
 +        fetched.image.write_to(&mut cursor, image::ImageFormat::Png)?;
 +        Ok(bytes)
 +    }
 +}

garbg/src/sources/s3.rsadded

 +//! S3 source provider
 +//!
 +//! Supports fetching wallpapers from S3 buckets and S3-compatible storage.
 +//!
 +//! URI format: `s3://bucket/prefix`
 +//!
 +//! Authentication is handled via:
 +//! - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables
 +//! - AWS credentials file (~/.aws/credentials)
 +//! - IAM instance roles (when running on EC2)
 +//!
 +//! For S3-compatible endpoints (MinIO, etc.):
 +//! - Set AWS_ENDPOINT_URL environment variable
++
 +#![cfg(feature = "s3")]
++
 +use anyhow::{Context, Result};
 +use async_trait::async_trait;
 +use aws_sdk_s3::Client;
 +use std::path::Path;
++
 +use super::{FetchedImage, MediaType, SourceProvider, WallpaperEntry};
 +use crate::media::ImageLoader;
++
 +/// Provider for S3 and S3-compatible object storage
 +pub struct S3Provider {
 +    client: Client,
 +}
++
 +impl S3Provider {
 +    /// Create a new S3 provider
 +    ///
 +    /// Loads credentials from environment or AWS config files.
 +    pub async fn new() -> Result<Self> {
 +        let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
 +        let client = Client::new(&config);
++
 +        Ok(Self { client })
 +    }
++
 +    /// Create with a custom endpoint URL (for S3-compatible services like MinIO)
 +    pub async fn with_endpoint(endpoint_url: &str) -> Result<Self> {
 +        let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
++
 +        let s3_config = aws_sdk_s3::config::Builder::from(&config)
 +            .endpoint_url(endpoint_url)
 +            .force_path_style(true) // Required for most S3-compatible services
 +            .build();
++
 +        let client = Client::from_conf(s3_config);
++
 +        Ok(Self { client })
 +    }
++
 +    /// Parse an s3:// URI into (bucket, prefix)
 +    fn parse_uri(uri: &str) -> Result<(String, String)> {
 +        let path = uri
 +            .strip_prefix("s3://")
 +            .context("Invalid S3 URI")?;
++
 +        let parts: Vec<&str> = path.splitn(2, '/').collect();
 +        let bucket = parts[0].to_string();
 +        let prefix = parts.get(1).map(|s| s.to_string()).unwrap_or_default();
++
 +        if bucket.is_empty() {
 +            anyhow::bail!("S3 URI must include a bucket: s3://bucket/prefix");
 +        }
++
 +        Ok((bucket, prefix))
 +    }
++
 +    /// Determine media type from key (path)
 +    fn media_type_from_key(key: &str) -> MediaType {
 +        let ext = Path::new(key)
 +            .extension()
 +            .and_then(|e| e.to_str())
 +            .map(|e| e.to_lowercase());
++
 +        match ext.as_deref() {
 +            Some("gif") => MediaType::AnimatedImage,
 +            Some("mp4" | "webm") => MediaType::Video,
 +            _ => MediaType::StaticImage,
 +        }
 +    }
++
 +    /// Check if a key is a supported image format
 +    fn is_image_key(key: &str) -> bool {
 +        ImageLoader::is_supported_format(Path::new(key))
 +    }
 +}
++
 +#[async_trait]
 +impl SourceProvider for S3Provider {
 +    fn id(&self) -> &str {
 +        "s3"
 +    }
++
 +    fn can_handle(&self, uri: &str) -> bool {
 +        uri.starts_with("s3://")
 +    }
++
 +    async fn list(&self, uri: &str) -> Result<Vec<WallpaperEntry>> {
 +        let (bucket, prefix) = Self::parse_uri(uri)?;
++
 +        tracing::debug!("Listing S3 objects: bucket={}, prefix={}", bucket, prefix);
++
 +        let mut entries = Vec::new();
 +        let mut continuation_token: Option<String> = None;
++
 +        // Paginate through results
 +        loop {
 +            let mut request = self.client
 +                .list_objects_v2()
 +                .bucket(&bucket)
 +                .prefix(&prefix);
++
 +            if let Some(token) = &continuation_token {
 +                request = request.continuation_token(token);
 +            }
++
 +            let response = request
 +                .send()
 +                .await
 +                .with_context(|| format!("Failed to list S3 bucket: {}", bucket))?;
++
 +            if let Some(contents) = response.contents {
 +                for object in contents {
 +                    if let Some(key) = object.key {
 +                        // Skip directory markers
 +                        if key.ends_with('/') {
 +                            continue;
 +                        }
++
 +                        // Only include supported image formats
 +                        if !Self::is_image_key(&key) {
 +                            continue;
 +                        }
++
 +                        let name = Path::new(&key)
 +                            .file_name()
 +                            .and_then(|n| n.to_str())
 +                            .unwrap_or(&key)
 +                            .to_string();
++
 +                        entries.push(WallpaperEntry {
 +                            uri: format!("s3://{}/{}", bucket, key),
 +                            name,
 +                            media_type: Self::media_type_from_key(&key),
 +                            size: object.size.map(|s| s as u64),
 +                            metadata: Default::default(),
 +                        });
 +                    }
 +                }
 +            }
++
 +            // Check for more results
 +            if response.is_truncated == Some(true) {
 +                continuation_token = response.next_continuation_token;
 +            } else {
 +                break;
 +            }
 +        }
++
 +        tracing::debug!("Found {} images in S3", entries.len());
 +        Ok(entries)
 +    }
++
 +    async fn fetch(&self, entry: &WallpaperEntry) -> Result<FetchedImage> {
 +        let (bucket, key) = Self::parse_uri(&entry.uri)?;
++
 +        tracing::debug!("Fetching S3 object: bucket={}, key={}", bucket, key);
++
 +        let response = self.client
 +            .get_object()
 +            .bucket(&bucket)
 +            .key(&key)
 +            .send()
 +            .await
 +            .with_context(|| format!("Failed to fetch S3 object: {}", entry.uri))?;
++
 +        let bytes = response
 +            .body
 +            .collect()
 +            .await
 +            .context("Failed to read S3 object body")?
 +            .into_bytes();
++
 +        let image = ImageLoader::load_bytes(&bytes, None)?;
++
 +        Ok(FetchedImage {
 +            image,
 +            uri: entry.uri.clone(),
 +            media_type: entry.media_type,
 +        })
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_parse_uri() {
 +        let (bucket, prefix) = S3Provider::parse_uri("s3://my-bucket/wallpapers/").unwrap();
 +        assert_eq!(bucket, "my-bucket");
 +        assert_eq!(prefix, "wallpapers/");
++
 +        let (bucket, prefix) = S3Provider::parse_uri("s3://bucket").unwrap();
 +        assert_eq!(bucket, "bucket");
 +        assert_eq!(prefix, "");
++
 +        let (bucket, prefix) = S3Provider::parse_uri("s3://bucket/path/to/file.png").unwrap();
 +        assert_eq!(bucket, "bucket");
 +        assert_eq!(prefix, "path/to/file.png");
 +    }
++
 +    #[test]
 +    fn test_invalid_uri() {
 +        assert!(S3Provider::parse_uri("http://example.com").is_err());
 +        assert!(S3Provider::parse_uri("s3://").is_err());
 +    }
 +}