47lecoste's advanced modulation hopper merge

Removed the Implemented Protocols section from the README.

.github/ISSUE_TEMPLATE/01_bug_report.yml

@@ -1,45 +1,77 @@
-name: Bug report
-description: File a bug reports regarding the firmware.
+name: Bug Report
+description: Report a bug in Flipper-ARF firmware.
 labels: ["bug"]
 body:
   - type: markdown
     attributes:
       value: |
-        Thank you for taking the time to fill out an issue, this template is meant for any issues related to the Flipper Zero unleashed firmware.
+        Thanks for reporting a bug in Flipper-ARF. Please fill in as much detail as possible.
+  - type: input
+    id: firmware-version
+    attributes:
+      label: Firmware version
+      description: "ARF version or git commit hash."
+      placeholder: "e.g. ARF 0.1.2 or commit abc1234"
+    validations:
+      required: true
+  - type: dropdown
+    id: hardware
+    attributes:
+      label: Hardware setup
+      description: "Which hardware configuration are you using?"
+      options:
+        - Flipper Zero (stock)
+        - Flipper Zero (modded antenna)
+        - Flipper Zero + external CC1101
+        - Other (describe below)
+    validations:
+      required: true
+  - type: input
+    id: protocol
+    attributes:
+      label: Protocol affected
+      description: "Which protocol is affected, if applicable?"
+      placeholder: "e.g. Kia V3/V4, PSA GROUP, Keeloq, Fiat Mystery"
+  - type: input
+    id: frequency
+    attributes:
+      label: Frequency & modulation
+      description: "RF frequency and modulation used, if relevant."
+      placeholder: "e.g. 433.92 MHz AM"
   - type: textarea
     id: description
     attributes:
-      label: Describe the bug.
-      description: "A clear and concise description of what the bug is."
+      label: Bug description
+      description: "A clear and concise description of the bug."
     validations:
       required: true
   - type: textarea
     id: repro
     attributes:
-      label: Reproduction
+      label: Steps to reproduce
       description: "How can this bug be reproduced?"
       placeholder: |
-        1. Switch on...
-        2. Press button '....'
-        3. Wait for the moon phase
-        4. It burns
+        1. Open SubGhz app
+        2. Load saved .sub file
+        3. Press Send
+        4. Observe error / unexpected behavior
     validations:
       required: true
-  - type: input
-    id: target
+  - type: textarea
+    id: expected
     attributes:
-      label: Target
-      description: Specify the target
-      # Target seems to be largely ignored by outside sources.
+      label: Expected vs actual behavior
+      description: "What did you expect to happen, and what actually happened?"
+    validations:
+      required: true
   - type: textarea
     id: logs
     attributes:
-      label: Logs
-      description: Attach your debug logs here
+      label: Logs / screenshots
+      description: "Attach debug logs (via serial CLI) or screenshots if available."
       render: Text
-      # Avoid rendering as Markdown here.
   - type: textarea
     id: anything-else
     attributes:
-      label: Anything else?
-      description: Let us know if you have anything else to share.
+      label: Additional context
+      description: "Any other information that might help (vehicle model, .sub file contents, etc.)."

.github/ISSUE_TEMPLATE/02_enhancements.yml

@@ -1,20 +0,0 @@
-name: Enhancements
-description: Suggest improvements for any existing functionality within the firmware.
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to fill out an issue. This template is meant for feature requests and improvements to already existing functionality.
-  - type: textarea
-    id: proposal
-    attributes:
-      label: "Describe the enhancement you're suggesting."
-      description: |
-        Feel free to describe in as much detail as you wish.
-    validations:
-      required: true
-  - type: textarea
-    id: anything-else
-    attributes:
-      label: Anything else?
-      description: Let us know if you have anything else to share.

.github/ISSUE_TEMPLATE/03_feature_request.yml

@@ -1,23 +1,46 @@
 name: Feature Request
-description: For feature requests regarding the firmware.
+description: Suggest a new feature or improvement for Flipper-ARF.
 labels: ["feature request"]
 body:
   - type: markdown
     attributes:
       value: |
-        Thank you for taking the time to fill out an issue, this template is meant for any feature suggestions.
-  - type: textarea
-    id: proposal
+        Thanks for suggesting a feature for Flipper-ARF. Please describe your idea in detail.
+  - type: dropdown
+    id: category
     attributes:
-      label: "Description of the feature you're suggesting."
-      description: |
-        Please describe your feature request in as many details as possible.
-          - Describe what it should do.
-          - Note whetever it is to extend existing functionality or introduce new functionality.
+      label: Category
+      description: "What area does this feature fall under?"
+      options:
+        - New protocol
+        - Protocol improvement
+        - UI / UX
+        - Build system / tooling
+        - Other
+    validations:
+      required: true
+  - type: input
+    id: manufacturer
+    attributes:
+      label: Manufacturer / protocol
+      description: "Which manufacturer or protocol is this related to, if applicable?"
+      placeholder: "e.g. Toyota, Renault, Keeloq"
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: "Describe the feature you're suggesting."
+    validations:
+      required: true
+  - type: textarea
+    id: use-case
+    attributes:
+      label: Use case
+      description: "Why is this needed? What problem does it solve?"
     validations:
       required: true
   - type: textarea
     id: anything-else
     attributes:
-      label: Anything else?
-      description: Let us know if you have anything else to share.
+      label: Additional context
+      description: "Any references, datasheets, links, or examples that support this request."

.github/ISSUE_TEMPLATE/04_protocol_submission.yml

@@ -0,0 +1,111 @@
+name: Protocol / Algorithm Submission
+description: Submit a new protocol decoder, encoder, or cipher implementation.
+labels: ["protocol", "contribution"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Use this template to submit a new protocol implementation or algorithm for inclusion in Flipper-ARF.
+        Include as much technical detail as possible — timing, frame structure, cipher type, and test captures.
+  - type: input
+    id: protocol-name
+    attributes:
+      label: Protocol name
+      description: "Name for the protocol (as it should appear in the firmware)."
+      placeholder: "e.g. Renault V2, Opel Corsa, Nissan V0"
+    validations:
+      required: true
+  - type: input
+    id: manufacturer
+    attributes:
+      label: Manufacturer / vehicle
+      description: "Which manufacturer or vehicles use this protocol?"
+      placeholder: "e.g. Renault Clio 2010-2018, Opel/Vauxhall Corsa D"
+    validations:
+      required: true
+  - type: input
+    id: frequency
+    attributes:
+      label: Frequency & modulation
+      description: "RF frequency and modulation type."
+      placeholder: "e.g. 433.92 MHz FM (FSK)"
+    validations:
+      required: true
+  - type: dropdown
+    id: encoding
+    attributes:
+      label: Encoding
+      description: "How are bits encoded in the RF signal?"
+      options:
+        - PWM (Pulse Width Modulation)
+        - Manchester
+        - Differential Manchester
+        - OOK raw
+        - Other (describe in frame structure)
+    validations:
+      required: true
+  - type: textarea
+    id: timing
+    attributes:
+      label: Timing parameters
+      description: "Provide timing values for the protocol."
+      placeholder: |
+        te_short: 400 us
+        te_long: 800 us
+        te_delta: 150 us
+        Preamble: 16 pairs of alternating short pulses
+        Sync: 1200 us HIGH
+        Gap: 10000 us between bursts
+    validations:
+      required: true
+  - type: textarea
+    id: frame-structure
+    attributes:
+      label: Frame structure
+      description: "Describe the bit layout — field positions, sizes, fixed vs rolling parts."
+      placeholder: |
+        Total bits: 68
+        Bits 0-31: Encrypted (KeeLoq)
+        Bits 32-59: Serial (28 bits)
+        Bits 60-63: Button code (4 bits)
+        Bits 64-67: CRC (4 bits, XOR of nibbles)
+    validations:
+      required: true
+  - type: dropdown
+    id: cipher
+    attributes:
+      label: Cipher / rolling code type
+      description: "What cipher or rolling code scheme does this protocol use?"
+      options:
+        - None (static code)
+        - KeeLoq
+        - AES
+        - TEA / XTEA
+        - Hitag2
+        - Custom / proprietary
+        - Unknown (needs analysis)
+    validations:
+      required: true
+  - type: dropdown
+    id: status
+    attributes:
+      label: Implementation status
+      description: "How far along is the implementation?"
+      options:
+        - Concept only (analysis / documentation)
+        - Decoder working
+        - Encoder working
+        - Both decoder and encoder working
+    validations:
+      required: true
+  - type: textarea
+    id: captures
+    attributes:
+      label: Test captures
+      description: "Paste .sub file contents or raw pulse data for validation. Attach files if too large."
+      render: Text
+  - type: textarea
+    id: references
+    attributes:
+      label: References
+      description: "Links to datasheets, research papers, FCC filings, or related projects."

.github/ISSUE_TEMPLATE/05_key_recording_submission.yml

@@ -0,0 +1,99 @@
+name: Key Recording Submission
+description: Contribute captured keyfob recordings for protocol analysis.
+labels: ["recording", "data"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Use this template to submit captured keyfob recordings (.sub files or raw data).
+        These recordings help with protocol reverse engineering, decoder validation, and cipher analysis.
+
+        **Tips for useful captures:**
+        - Record 10+ sequential presses per button without long gaps
+        - Note the exact button pressed for each capture
+        - If possible, capture from multiple buttons on the same fob
+        - Include the vehicle make, model, and year
+  - type: input
+    id: vehicle
+    attributes:
+      label: Vehicle / device
+      description: "Make, model, year, and any relevant trim info."
+      placeholder: "e.g. 2015 Fiat Panda 1.2 Pop"
+    validations:
+      required: true
+  - type: dropdown
+    id: protocol
+    attributes:
+      label: Protocol (if known)
+      description: "Which protocol was detected, or select Unknown if not yet identified."
+      options:
+        - Unknown / new protocol
+        - VAG GROUP
+        - Cayenne
+        - PSA GROUP
+        - Ford V0
+        - Fiat SpA
+        - Fiat Mystery
+        - Subaru
+        - Siemens (Mazda)
+        - Kia V0
+        - Kia V1
+        - Kia V2
+        - Kia V3/V4
+        - Kia V5
+        - Kia V6
+        - Suzuki
+        - Mitsubishi V0
+        - Keeloq
+        - Other (specify below)
+    validations:
+      required: true
+  - type: input
+    id: frequency
+    attributes:
+      label: Frequency & modulation used
+      description: "The frequency and modulation setting used during capture."
+      placeholder: "e.g. 433.92 MHz AM650"
+    validations:
+      required: true
+  - type: input
+    id: buttons
+    attributes:
+      label: Button / function
+      description: "Which buttons were recorded and what they do."
+      placeholder: "e.g. Lock (Btn A), Unlock (Btn B), Trunk (Btn C)"
+    validations:
+      required: true
+  - type: input
+    id: num-captures
+    attributes:
+      label: Number of captures
+      description: "How many presses were recorded per button?"
+      placeholder: "e.g. 10 sequential presses per button"
+    validations:
+      required: true
+  - type: dropdown
+    id: capture-method
+    attributes:
+      label: Capture method
+      description: "How were the signals captured?"
+      options:
+        - SubGhz Read RAW
+        - SubGhz decoded (saved .sub)
+        - External SDR (HackRF, RTL-SDR, etc.)
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    id: capture-data
+    attributes:
+      label: Capture data
+      description: "Paste .sub file contents here, or attach files. For multiple files, use separate code blocks labeled by button."
+      render: Text
+    validations:
+      required: true
+  - type: textarea
+    id: notes
+    attributes:
+      label: Notes
+      description: "Any observations — counter gaps, time between captures, battery changes, multiple fobs, etc."

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1 @@
 blank_issues_enabled: true
-contact_links:
-  - name: Telegram
-    url: https://t.me/flipperzero_unofficial
-    about: Unofficial Telegram chat
-  - name: Discord
-    url: https://discord.unleashedflip.com
-    about: Unofficial Discord Community

.github/pull_request_template.md

@@ -1,13 +1,25 @@
-# What's new
+## Summary
 
-- [ Describe changes here ]
+<!-- What changed and why? Keep it concise. -->
 
-# Verification 
+## Protocol(s) affected
 
-- [ Describe how to verify changes ]
+<!-- Which protocol(s) does this PR touch? e.g. Kia V3/V4, PSA GROUP, none -->
 
-# Checklist (For Reviewer)
+## Type of change
 
-- [ ] PR has description of feature/bug
-- [ ] Description contains actions to verify feature/bugfix
-- [ ] I've built this code, uploaded it to the device and verified feature/bugfix
+- [ ] Bug fix
+- [ ] New protocol
+- [ ] Protocol improvement (encoder/decoder/display)
+- [ ] Build system / infrastructure
+- [ ] Other
+
+## Testing
+
+<!-- How was this verified? Include hardware used, captures tested, etc. -->
+
+## Checklist
+
+- [ ] Built with `./fbt COMPACT=1 DEBUG=0 updater_package` (no errors)
+- [ ] Flashed and tested on Flipper Zero
+- [ ] No regressions in other protocols

CODE_OF_CONDUCT.md

@@ -1,128 +1,94 @@
-# Contributor Covenant Code of Conduct
+# Flipper-ARF Code of Conduct
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
+We as members, contributors, and maintainers of Flipper-ARF pledge to make participation in this project a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
 
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
+We pledge to act and interact in ways that contribute to an open, welcoming, and responsible research community.
 
-## Our Standards
+## Ethical Research Standards
 
-Examples of behavior that contributes to a positive environment for our
-community include:
+Flipper-ARF is an automotive security research project. All contributions, discussions, and use of this project must adhere to the following ethical standards:
 
-* Demonstrating empathy and kindness toward other people
+1. **Lawful purpose only.** All work must be for lawful, educational, or explicitly authorized security research purposes. Contributors must comply with all applicable local, national, and international laws.
+
+2. **No unauthorized access.** Do not use this firmware or any knowledge gained from it to access vehicles, devices, or systems without explicit authorization from the owner.
+
+3. **Responsible disclosure.** If your research reveals a vulnerability in a manufacturer's system, follow responsible disclosure practices — notify the manufacturer and allow reasonable time for remediation before any public disclosure.
+
+4. **Key material handling.** Do not share manufacturer-specific cryptographic keys, seeds, or proprietary algorithms outside the scope of this project's research goals. Key material included in the project is for protocol interoperability research only.
+
+5. **Authorized captures only.** Signal captures and key recordings submitted to the project should come from researcher-owned vehicles or devices, or be obtained with explicit written permission from the owner.
+
+6. **No enabling of criminal activity.** We do not condone/support/endorse vehicle theft, unauthorized entry, tracking, surveillance, or any other criminal activity.
+
+7. **Radio frequency compliance.** Comply with radio frequency regulations in your jurisdiction. Transmission testing should be conducted in controlled environments or within legally permitted parameters.
+
+## Community Standards
+
+Examples of behavior that contributes to a positive environment:
+
+* Sharing well-documented protocol analysis and research findings
+* Providing detailed capture data with proper context (vehicle, method, conditions)
 * Being respectful of differing opinions, viewpoints, and experiences
 * Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
+* Accepting responsibility and apologizing to those affected by our mistakes
 
-Examples of unacceptable behavior include:
+Examples of unacceptable behavior:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
+* Sharing techniques specifically intended to facilitate vehicle theft or unauthorized access
+* The use of sexualized language or imagery, and sexual attention or advances of any kind
 * Trolling, insulting or derogatory comments, and personal or political attacks
 * Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
+* Publishing others' private information without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional or research setting
 
 ## Enforcement Responsibilities
 
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
+Project maintainers are responsible for clarifying and enforcing these standards and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, harmful, or in violation of the ethical research standards above.
 
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
+Maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
 
 ## Scope
 
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
+This Code of Conduct applies within all project spaces, including the repository, issue tracker, pull requests, and any associated communication channels. It also applies when an individual is representing the project in public spaces.
 
-## Enforcement
+## Reporting
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-hello@flipperdevices.com.
-All complaints will be reviewed and investigated promptly and fairly.
+Instances of abusive, harassing, unethical, or otherwise unacceptable behavior may be reported by opening a confidential issue on the project's GitHub repository or by contacting the maintainers directly through GitHub.
 
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
+All complaints will be reviewed and investigated promptly and fairly. All maintainers are obligated to respect the privacy and security of the reporter of any incident.
 
 ## Enforcement Guidelines
 
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
+Maintainers will follow these guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
 
 ### 1. Correction
 
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
+**Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome.
 
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
+**Consequence**: A private, written warning providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
 
 ### 2. Warning
 
-**Community Impact**: A violation through a single incident or series
-of actions.
+**Impact**: A violation through a single incident or series of actions.
 
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. Violating these terms may lead to a temporary or permanent ban.
 
 ### 3. Temporary Ban
 
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
+**Impact**: A serious violation of community or ethical research standards, including sustained inappropriate behavior.
 
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
+**Consequence**: A temporary ban from any sort of interaction or public communication with the project for a specified period of time. Violating these terms may lead to a permanent ban.
 
 ### 4. Permanent Ban
 
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
+**Impact**: Demonstrating a pattern of violation of community or ethical standards, including sustained inappropriate behavior, harassment, or using the project to enable criminal activity.
 
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
+**Consequence**: A permanent ban from any sort of public interaction within the project.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 2.0, with additional ethical research guidelines specific to the Flipper-ARF project.
 
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).

README.md

@@ -10,6 +10,21 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 
 ---
 
+## Table of Contents
+
+- [Showcase](#showcase)
+- [Supported Systems](#supported-systems)
+- [How to Build](#how-to-build)
+- [Project Scope](#project-scope)
+- [To Do / Planned Features](#to-do--planned-features)
+- [Design Philosophy](#design-philosophy)
+- [Research Direction](#research-direction)
+- [Contribution Policy](#contribution-policy)
+- [Citations & References](#citations--references)
+- [Disclaimer](#disclaimer)
+
+---
+
 ## Showcase
 
 | | |
@@ -34,7 +49,7 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 | PSA (Peugeot/Citroën/DS) | PSA GROUP | 433 MHz | AM/FM | Yes | Yes |
 | Ford | Ford V0 | 315/433 MHz | AM | Yes | Yes |
 | Fiat | Fiat SpA | 433 MHz | AM | Yes | Yes |
-| Fiat | Fiat Mystery | 433 MHz | AM | No | Yes |
+| Fiat | Fiat Marelli | 433 MHz | AM | No | Yes |
 | Subaru | Subaru | 433 MHz | AM | Yes | Yes |
 | Mazda | Siemens (5WK49365D) | 315/433 MHz | FM | Yes | Yes |
 | Kia/Hyundai | Kia V0 | 433 MHz | FM | Yes | Yes |
@@ -116,22 +131,10 @@ Flipper-ARF aims to achieve:
 
 ---
 
-## Implemented Protocols
-
-- [x] Mazda Siemens Protocol (5WK49365D) — ported from open-source references (testing required)
-- [x] Full VAG, Fiat, Ford, Subaru, Kia, PSA support
-- [x] D-Pad mapping (Lock / Unlock / Boot / Trunk) during emulation
-- [x] VAG MFKey support and updated Keeloq codes
-- [x] PSA XTEA brute force for saved → emulation workflow
-- [x] Brute force of counter in saved → emulation scene for smoother keyfob emulation
-- [x] RollJam app (Internal CC1101 for RX & TX captured signal; External CC1101 for jamming) — requires more real-world testing
-
----
-
 ## To Do / Planned Features
 
-- [ ] Keeloq Key Manager inside firmware
 - [ ] Add Scher Khan & Starline protocols
+- [ ] Marelli BSI encodere and encryption
 - [ ] Fix and reintegrate RollJam app (future updates)
 - [ ] Expand and refine Subaru, Kia, PSA, and other manufacturer protocols
 - [ ] Improve collaboration workflow to avoid overlapping work
@@ -175,7 +178,134 @@ Contributions are welcome if they:
 > Non-automotive features are considered out-of-scope for now.
 
 ### This code is a mess!
-![Talk is cheap, submit patches](arf_pictures/send_patches.jpeg) 
+![Talk is cheap, submit patches](arf_pictures/send_patches.jpeg)
+---
+
+## Citations & References
+
+The following academic publications have been invaluable to the development and understanding of the protocols implemented in this firmware.
+
+### Automotive RKE Security
+
+- **Lock It and Still Lose It — On the (In)Security of Automotive Remote Keyless Entry Systems**
+  Flavio D. Garcia, David Oswald, Timo Kasper, Pierre Pavlidès
+  *USENIX Security 2016, pp. 929–944*
+  DOI: [10.5555/3241094.3241166](https://doi.org/10.5555/3241094.3241166)
+  https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_garcia.pdf
+
+- **Clonable Key Fobs: Analyzing and Breaking RKE Protocols**
+  Roberto Gesteira-Miñarro, Gregorio López, Rafael Palacios
+  *International Journal of Information Security, Springer, May 2025, 24(3)*
+  DOI: [10.1007/s10207-025-01063-7](https://doi.org/10.1007/s10207-025-01063-7)
+
+- **The Role of Cryptographic Techniques in Remote Keyless Entry (RKE) Systems**
+  Jananga Chiran — Sri Lanka Institute of Information Technology
+  *November 2023*
+  DOI: [10.5281/zenodo.14677864](https://doi.org/10.5281/zenodo.14677864)
+
+- **SoK: Stealing Cars Since Remote Keyless Entry Introduction and How to Defend From It**
+  Tommaso Bianchi, Alessandro Brighente, Mauro Conti, Edoardo Pavan — University of Padova / Delft University of Technology
+  *arXiv, 2025*
+  https://arxiv.org/pdf/2505.02713
+
+- **Security of Automotive Systems**
+  Lennert Wouters, Benedikt Gierlichs, Bart Preneel
+  *Wiley, February 2025*
+  DOI: [10.1002/9781394351930.ch11](https://doi.org/10.1002/9781394351930.ch11)
+
+### DST Cipher Family (DST40 / DST80)
+
+- **Security Analysis of a Cryptographically-Enabled RFID Device**
+  Steve Bono, Matthew Green, Adam Stubblefield, Ari Juels, Avi Rubin, Michael Szydlo
+  *14th USENIX Security Symposium (USENIX Security '05)*
+  https://www.usenix.org/conference/14th-usenix-security-symposium/security-analysis-cryptographically-enabled-rfid-device
+  https://www.usenix.org/legacy/event/sec05/tech/bono/bono.pdf
+
+- **Dismantling DST80-based Immobiliser Systems**
+  Lennert Wouters, Jan Van den Herrewegen, Flavio D. Garcia, David Oswald, Benedikt Gierlichs, Bart Preneel
+  *IACR Transactions on Cryptographic Hardware and Embedded Systems (TCHES), 2020, Vol. 2020(2), pp. 99–127*
+  DOI: [10.13154/tches.v2020.i2.99-127](https://doi.org/10.13154/tches.v2020.i2.99-127)
+
+### KeeLoq Cryptanalysis
+
+- **Cryptanalysis of the KeeLoq Block Cipher**
+  Andrey Bogdanov
+  *Cryptology ePrint Archive, Paper 2007/055; also presented at RFIDSec 2007*
+  https://eprint.iacr.org/2007/055
+
+- **A Practical Attack on KeeLoq**
+  Sebastiaan Indesteege, Nathan Keller, Orr Dunkelman, Eli Biham, Bart Preneel
+  *EUROCRYPT 2008 (LNCS vol. 4965, pp. 1–18)*
+  DOI: [10.1007/978-3-540-78967-3_1](https://doi.org/10.1007/978-3-540-78967-3_1)
+  https://www.iacr.org/archive/eurocrypt2008/49650001/49650001.pdf
+
+- **Algebraic and Slide Attacks on KeeLoq**
+  Nicolas T. Courtois, Gregory V. Bard, David Wagner
+  *FSE 2008 (LNCS vol. 5086, pp. 97–115)*
+  DOI: [10.1007/978-3-540-71039-4_6](https://doi.org/10.1007/978-3-540-71039-4_6)
+
+- **On the Power of Power Analysis in the Real World: A Complete Break of the KeeLoq Code Hopping Scheme**
+  Thomas Eisenbarth, Timo Kasper, Amir Moradi, Christof Paar, Mahmoud Salmasizadeh, Mohammad T. Manzuri Shalmani
+  *CRYPTO 2008 (LNCS vol. 5157, pp. 203–220)*
+  DOI: [10.1007/978-3-540-85174-5_12](https://doi.org/10.1007/978-3-540-85174-5_12)
+  https://www.iacr.org/archive/crypto2008/51570204/51570204.pdf
+
+- **Breaking KeeLoq in a Flash: On Extracting Keys at Lightning Speed**
+  Markus Kasper, Timo Kasper, Amir Moradi, Christof Paar
+  *AFRICACRYPT 2009 (LNCS vol. 5580, pp. 403–420)*
+  DOI: [10.1007/978-3-642-02384-2_25](https://doi.org/10.1007/978-3-642-02384-2_25)
+
+### Immobiliser & Transponder Cipher Attacks
+
+- **Gone in 360 Seconds: Hijacking with Hitag2**
+  Roel Verdult, Flavio D. Garcia, Josep Balasch
+  *21st USENIX Security Symposium (USENIX Security '12), pp. 237–252*
+  DOI: [10.5555/2362793.2362830](https://doi.org/10.5555/2362793.2362830)
+  https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final95.pdf
+
+- **Dismantling Megamos Crypto: Wirelessly Lockpicking a Vehicle Immobilizer**
+  Roel Verdult, Flavio D. Garcia, Baris Ege
+  *Supplement to 22nd USENIX Security Symposium (USENIX Security '13/15), pp. 703–718*
+  https://www.usenix.org/sites/default/files/sec15_supplement.pdf
+
+- **Dismantling the AUT64 Automotive Cipher**
+  Christopher Hicks, Flavio D. Garcia, David Oswald
+  *IACR Transactions on Cryptographic Hardware and Embedded Systems (TCHES), 2018, Vol. 2018(2), pp. 46–69*
+  DOI: [10.13154/tches.v2018.i2.46-69](https://doi.org/10.13154/tches.v2018.i2.46-69)
+
+### RFID & Protocol Analysis Tooling
+
+- **A Toolbox for RFID Protocol Analysis**
+  Flavio D. Garcia
+  *IEEE International Conference on RFID, 2012*
+  DOI: [10.1109/rfid.2012.19](https://doi.org/10.1109/rfid.2012.19)
+
+### Relay & Replay Attacks
+
+- **Relay Attacks on Passive Keyless Entry and Start Systems in Modern Cars**
+  Aurélien Francillon, Boris Danev, Srdjan Čapkun
+  *NDSS 2011*
+  https://www.ndss-symposium.org/ndss2011/relay-attacks-on-passive-keyless-entry-and-start-systems-in-modern-cars/
+
+- **Implementing and Testing RollJam on Software-Defined Radios**
+  *Università di Bologna (UNIBO), CRIS*
+  https://cris.unibo.it/handle/11585/999874
+
+- **Enhanced Vehicular Roll-Jam Attack Using a Known Noise Source**
+  *Inaugural International Symposium on Vehicle Security & Privacy, January 2023*
+  DOI: [10.14722/vehiclesec.2023.23037](https://doi.org/10.14722/vehiclesec.2023.23037)
+
+- **RollBack: A New Time-Agnostic Replay Attack Against the Automotive Remote Keyless Entry Systems**
+  Levente Csikor, Hoon Wei Lim, Jun Wen Wong, Soundarya Ramesh, Rohini Poolat Parameswarath, Mun Choon Chan
+  *Black Hat USA 2022; ACM Transactions on Cyber-Physical Systems, 2024*
+  DOI: [10.1145/3627827](https://doi.org/10.1145/3627827)
+  https://i.blackhat.com/USA-22/Thursday/US-22-Csikor-Rollback-A-New-Time-Agnostic-Replay-wp.pdf
+
+- **Rolling-PWN Attack (Honda RKE Vulnerability)**
+  Kevin2600 (Haoqi Shan), Wesley Li — Star-V Lab
+  *Independent disclosure, 2022 (CVE-2021-46145)*
+  https://rollingpwn.github.io/rolling-pwn/
+
 ---
 
 # Disclaimer

applications/main/flipperzero-subbrute/application.fam

@@ -6,7 +6,7 @@ App(
     requires=["gui","dialogs"],
     stack_size=2 * 1024,
     order=11,
-    fap_icon="images/subbrute_10px.png",
+    fap_icon="icon.png",
     fap_category="Sub-GHz",
     fap_icon_assets="images",
 )

applications/main/subghz/helpers/subghz_txrx.c

@@ -1,5 +1,6 @@
 #include "subghz_txrx_i.h" // IWYU pragma: keep
 
+#include <math.h>
 #include <lib/subghz/protocols/protocol_items.h>
 #include <applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h>
 #include <lib/subghz/devices/cc1101_int/cc1101_int_interconnect.h>
@@ -34,6 +35,9 @@ SubGhzTxRx* subghz_txrx_alloc(void) {
     instance->txrx_state = SubGhzTxRxStateSleep;
 
     subghz_txrx_hopper_set_state(instance, SubGhzHopperStateOFF);
+    subghz_txrx_preset_hopper_set_state(instance, SubGhzPresetHopperStateOFF);
+    instance->preset_hopper_idx = 0;
+    instance->preset_hopper_timeout = 0;
     subghz_txrx_speaker_set_state(instance, SubGhzSpeakerStateDisable);
     subghz_txrx_set_debug_pin_state(instance, false);
 
@@ -494,52 +498,153 @@ void subghz_txrx_hopper_pause(SubGhzTxRx* instance) {
     }
 }
 
-#define SUBGHZ_MOD_HOPPER_DWELL_TICKS 3
-
-bool subghz_txrx_mod_hopper_get_running(SubGhzTxRx* instance) {
+void subghz_txrx_preset_hopper_update(SubGhzTxRx* instance, float stay_threshold) {
     furi_assert(instance);
-    return instance->mod_hopper_running;
-}
 
-void subghz_txrx_mod_hopper_set_running(SubGhzTxRx* instance, bool running) {
-    furi_assert(instance);
-    instance->mod_hopper_running = running;
-    if(running) instance->mod_hopper_timer = SUBGHZ_MOD_HOPPER_DWELL_TICKS;
-}
-
-void subghz_txrx_mod_hopper_update(SubGhzTxRx* instance) {
-    furi_assert(instance);
-    if(!instance->mod_hopper_running) return;
-
-    if(instance->mod_hopper_timer > 0) {
-        instance->mod_hopper_timer--;
+    switch(instance->preset_hopper_state) {
+    case SubGhzPresetHopperStateOFF:
+    case SubGhzPresetHopperStatePause:
         return;
+    case SubGhzPresetHopperStateRSSITimeOut:
+        if(instance->preset_hopper_timeout != 0) {
+            instance->preset_hopper_timeout--;
+            return;
+        }
+        break;
+    default:
+        break;
     }
-    instance->mod_hopper_timer = SUBGHZ_MOD_HOPPER_DWELL_TICKS;
 
-    size_t count = subghz_setting_get_preset_count(instance->setting);
-    if(count == 0) return;
+    if(instance->preset_hopper_state != SubGhzPresetHopperStateRSSITimeOut) {
+        float rssi = subghz_devices_get_rssi(instance->radio_device);
 
-    // Advance index, skip CUSTOM presets
-    uint8_t tries = 0;
-    do {
-        instance->mod_hopper_idx = (instance->mod_hopper_idx + 1) % count;
-        tries++;
-    } while(tries < count &&
-            strcmp(
-                subghz_setting_get_preset_name(instance->setting, instance->mod_hopper_idx),
-                "CUSTOM") == 0);
+        if(rssi > stay_threshold) {
+            instance->preset_hopper_timeout = 20;
+            instance->preset_hopper_state = SubGhzPresetHopperStateRSSITimeOut;
+            return;
+        }
+    } else {
+        instance->preset_hopper_state = SubGhzPresetHopperStateRunning;
+    }
 
-    const char* preset_name =
-        subghz_setting_get_preset_name(instance->setting, instance->mod_hopper_idx);
-    uint8_t* preset_data =
-        subghz_setting_get_preset_data(instance->setting, instance->mod_hopper_idx);
-    size_t preset_data_size =
-        subghz_setting_get_preset_data_size(instance->setting, instance->mod_hopper_idx);
+    size_t hopper_preset_count = subghz_setting_get_hopper_preset_count(instance->setting);
 
-    subghz_txrx_set_preset(
-        instance, preset_name, instance->preset->frequency, preset_data, preset_data_size);
-    subghz_txrx_rx_start(instance);
+    if(hopper_preset_count > 0) {
+        if(instance->preset_hopper_idx < hopper_preset_count - 1) {
+            instance->preset_hopper_idx++;
+        } else {
+            instance->preset_hopper_idx = 0;
+        }
+
+        size_t actual_preset_idx = subghz_setting_get_hopper_preset_index(
+            instance->setting, instance->preset_hopper_idx);
+
+        if(instance->txrx_state == SubGhzTxRxStateRx) {
+            subghz_txrx_rx_end(instance);
+        }
+        if(instance->txrx_state == SubGhzTxRxStateIDLE) {
+            const char* old_preset_name = furi_string_get_cstr(instance->preset->name);
+
+            const char* preset_name =
+                subghz_setting_get_preset_name(instance->setting, actual_preset_idx);
+            subghz_txrx_set_preset_internal(
+                instance, instance->preset->frequency, actual_preset_idx, 0);
+
+            bool old_is_am = (strstr(old_preset_name, "AM") != NULL);
+            bool new_is_am = (strstr(preset_name, "AM") != NULL);
+            bool modulation_changed = (old_is_am != new_is_am);
+
+            if(modulation_changed) {
+                subghz_devices_reset(instance->radio_device);
+                subghz_devices_load_preset(
+                    instance->radio_device,
+                    FuriHalSubGhzPresetCustom,
+                    instance->preset->data);
+            } else {
+                subghz_devices_load_preset(
+                    instance->radio_device,
+                    FuriHalSubGhzPresetCustom,
+                    instance->preset->data);
+            }
+
+            subghz_txrx_rx(instance, instance->preset->frequency);
+        }
+    } else {
+        size_t preset_count = subghz_setting_get_preset_count(instance->setting);
+        if(instance->preset_hopper_idx < preset_count - 1) {
+            instance->preset_hopper_idx++;
+        } else {
+            instance->preset_hopper_idx = 0;
+        }
+
+        if(instance->txrx_state == SubGhzTxRxStateRx) {
+            subghz_txrx_rx_end(instance);
+        }
+        if(instance->txrx_state == SubGhzTxRxStateIDLE) {
+            const char* old_preset_name = furi_string_get_cstr(instance->preset->name);
+
+            const char* preset_name =
+                subghz_setting_get_preset_name(instance->setting, instance->preset_hopper_idx);
+            subghz_txrx_set_preset_internal(
+                instance, instance->preset->frequency, instance->preset_hopper_idx, 0);
+
+            bool old_is_am = (strstr(old_preset_name, "AM") != NULL);
+            bool new_is_am = (strstr(preset_name, "AM") != NULL);
+            bool modulation_changed = (old_is_am != new_is_am);
+
+            if(modulation_changed) {
+                subghz_devices_reset(instance->radio_device);
+                subghz_devices_load_preset(
+                    instance->radio_device,
+                    FuriHalSubGhzPresetCustom,
+                    instance->preset->data);
+            } else {
+                subghz_devices_load_preset(
+                    instance->radio_device,
+                    FuriHalSubGhzPresetCustom,
+                    instance->preset->data);
+            }
+
+            subghz_txrx_rx(instance, instance->preset->frequency);
+        }
+    }
+}
+
+SubGhzPresetHopperState subghz_txrx_preset_hopper_get_state(SubGhzTxRx* instance) {
+    furi_assert(instance);
+    return instance->preset_hopper_state;
+}
+
+void subghz_txrx_preset_hopper_set_state(SubGhzTxRx* instance, SubGhzPresetHopperState state) {
+    furi_assert(instance);
+    instance->preset_hopper_state = state;
+
+    if(state == SubGhzPresetHopperStateRunning) {
+        subghz_devices_reset(instance->radio_device);
+        subghz_devices_load_preset(
+            instance->radio_device,
+            FuriHalSubGhzPresetCustom,
+            instance->preset->data);
+    }
+}
+
+void subghz_txrx_preset_hopper_unpause(SubGhzTxRx* instance) {
+    furi_assert(instance);
+    if(instance->preset_hopper_state == SubGhzPresetHopperStatePause) {
+        instance->preset_hopper_state = SubGhzPresetHopperStateRunning;
+    }
+}
+
+void subghz_txrx_preset_hopper_pause(SubGhzTxRx* instance) {
+    furi_assert(instance);
+    if(instance->preset_hopper_state == SubGhzPresetHopperStateRunning) {
+        instance->preset_hopper_state = SubGhzPresetHopperStatePause;
+    }
+}
+
+void subghz_txrx_preset_hopper_reset_index(SubGhzTxRx* instance, size_t index) {
+    furi_assert(instance);
+    instance->preset_hopper_idx = index;
 }
 
 void subghz_txrx_speaker_on(SubGhzTxRx* instance) {

applications/main/subghz/helpers/subghz_txrx.h

@@ -164,29 +164,17 @@ void subghz_txrx_hopper_unpause(SubGhzTxRx* instance);
  */
 void subghz_txrx_hopper_pause(SubGhzTxRx* instance);
 
-/**
- * Update modulation (preset) CC1101 in automatic mode (mod hopper)
- * Cycles through available presets at a fixed dwell time.
- *
- * @param instance Pointer to a SubGhzTxRx
- */
-void subghz_txrx_mod_hopper_update(SubGhzTxRx* instance);
+void subghz_txrx_preset_hopper_update(SubGhzTxRx* instance, float stay_threshold);
 
-/**
- * Set mod hopper running state
- *
- * @param instance Pointer to a SubGhzTxRx
- * @param running  true to enable, false to disable
- */
-void subghz_txrx_mod_hopper_set_running(SubGhzTxRx* instance, bool running);
+SubGhzPresetHopperState subghz_txrx_preset_hopper_get_state(SubGhzTxRx* instance);
 
-/**
- * Get mod hopper running state
- *
- * @param instance Pointer to a SubGhzTxRx
- * @return true if mod hopping is active
- */
-bool subghz_txrx_mod_hopper_get_running(SubGhzTxRx* instance);
+void subghz_txrx_preset_hopper_set_state(SubGhzTxRx* instance, SubGhzPresetHopperState state);
+
+void subghz_txrx_preset_hopper_unpause(SubGhzTxRx* instance);
+
+void subghz_txrx_preset_hopper_pause(SubGhzTxRx* instance);
+
+void subghz_txrx_preset_hopper_reset_index(SubGhzTxRx* instance, size_t index);
 
 /**
  * Speaker on

applications/main/subghz/helpers/subghz_txrx_i.h

@@ -19,9 +19,9 @@ struct SubGhzTxRx {
     bool is_database_loaded;
     SubGhzHopperState hopper_state;
 
-    uint8_t mod_hopper_idx;     // index into setting presets (wraps around)
-    uint8_t mod_hopper_timer;   // countdown ticks before advancing modulation
-    bool mod_hopper_running;    // is mod hopping active
+    uint8_t preset_hopper_timeout;
+    size_t preset_hopper_idx;
+    SubGhzPresetHopperState preset_hopper_state;
 
     SubGhzTxRxState txrx_state;
     SubGhzSpeakerState speaker_state;

applications/main/subghz/helpers/subghz_types.h

@@ -29,6 +29,14 @@ typedef enum {
     SubGhzHopperStateRSSITimeOut,
 } SubGhzHopperState;
 
+/** SubGhzPresetHopperState state */
+typedef enum {
+    SubGhzPresetHopperStateOFF,
+    SubGhzPresetHopperStateRunning,
+    SubGhzPresetHopperStatePause,
+    SubGhzPresetHopperStateRSSITimeOut,
+} SubGhzPresetHopperState;
+
 /** SubGhzSpeakerState state */
 typedef enum {
     SubGhzSpeakerStateDisable,

applications/main/subghz/resources/subghz/assets/setting_user.example

@@ -40,3 +40,8 @@ Version: 1
 #Custom_preset_name: AM_2
 #Custom_preset_module: CC1101
 #Custom_preset_data: 02 0D 03 07 08 32 0B 06 14 00 13 00 12 30 11 32 10 17 18 18 19 18 1D 91 1C 00 1B 07 20 FB 22 11 21 B6 00 00 00 C0 00 00 00 00 00 00
+
+# Presets used for preset hopping mode (cycles through these modulations)
+#Hopping_Preset: AM650
+#Hopping_Preset: FM238
+#Hopping_Preset: FM476

applications/main/subghz/scenes/subghz_scene_receiver.c

@@ -213,7 +213,12 @@ void subghz_scene_receiver_on_enter(void* context) {
     } else {
         subghz_txrx_hopper_set_state(subghz->txrx, SubGhzHopperStateOFF);
     }
-    subghz_txrx_mod_hopper_set_running(subghz->txrx, subghz->last_settings->enable_mod_hopping);
+
+    if(subghz->last_settings->enable_preset_hopping) {
+        subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateRunning);
+    } else {
+        subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateOFF);
+    }
 
     subghz_txrx_rx_start(subghz->txrx);
     subghz_view_receiver_set_idx_menu(subghz->subghz_receiver, subghz->idx_menu_chosen);
@@ -242,6 +247,7 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             subghz->state_notifications = SubGhzNotificationStateIDLE;
             subghz_txrx_stop(subghz->txrx);
             subghz_txrx_hopper_set_state(subghz->txrx, SubGhzHopperStateOFF);
+            subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateOFF);
             subghz_txrx_set_rx_callback(subghz->txrx, NULL, subghz);
 
             if(subghz_rx_key_state_get(subghz) == SubGhzRxKeyStateAddKey) {
@@ -302,8 +308,8 @@ bool subghz_scene_receiver_on_event(void* context, SceneManagerEvent event) {
             subghz_txrx_hopper_update(subghz->txrx, subghz->last_settings->hopping_threshold);
             subghz_scene_receiver_update_statusbar(subghz);
         }
-        if(subghz_txrx_mod_hopper_get_running(subghz->txrx)) {
-            subghz_txrx_mod_hopper_update(subghz->txrx);
+        if(subghz_txrx_preset_hopper_get_state(subghz->txrx) != SubGhzPresetHopperStateOFF) {
+            subghz_txrx_preset_hopper_update(subghz->txrx, subghz->last_settings->preset_hopping_threshold);
             subghz_scene_receiver_update_statusbar(subghz);
         }
 

applications/main/subghz/scenes/subghz_scene_receiver_config.c

@@ -1,13 +1,14 @@
 #include "../subghz_i.h"
 #include <lib/toolbox/value_index.h>
+#include <math.h>
 
 #define TAG "SubGhzSceneReceiverConfig"
 
 enum SubGhzSettingIndex {
     SubGhzSettingIndexFrequency,
-    SubGhzSettingIndexHopping,
     SubGhzSettingIndexModulation,
-    SubGhzSettingIndexModHopping,
+    SubGhzSettingIndexHopping,
+    SubGhzSettingIndexPresetHopping,
     SubGhzSettingIndexBinRAW,
     SubGhzSettingIndexIgnoreReversRB2,
     SubGhzSettingIndexIgnoreAlarms,
@@ -81,6 +82,36 @@ const float hopping_mode_value[HOPPING_MODE_COUNT] = {
     -40.0f,
 };
 
+#define PRESET_HOPPING_MODE_COUNT 12
+const char* const preset_hopping_mode_text[PRESET_HOPPING_MODE_COUNT] = {
+    "OFF",
+    "-90dBm",
+    "-85dBm",
+    "-80dBm",
+    "-75dBm",
+    "-70dBm",
+    "-65dBm",
+    "-60dBm",
+    "-55dBm",
+    "-50dBm",
+    "-45dBm",
+    "-40dBm",
+};
+const float preset_hopping_mode_value[PRESET_HOPPING_MODE_COUNT] = {
+    NAN,
+    -90.0f,
+    -85.0f,
+    -80.0f,
+    -75.0f,
+    -70.0f,
+    -65.0f,
+    -60.0f,
+    -55.0f,
+    -50.0f,
+    -45.0f,
+    -40.0f,
+};
+
 #define COMBO_BOX_COUNT 2
 
 const uint32_t hopping_value[COMBO_BOX_COUNT] = {
@@ -153,6 +184,23 @@ uint8_t subghz_scene_receiver_config_next_preset(const char* preset_name, void*
     return index;
 }
 
+uint8_t subghz_scene_receiver_config_preset_hopper_value_index(void* context) {
+    furi_assert(context);
+    SubGhz* subghz = context;
+
+    if(subghz_txrx_preset_hopper_get_state(subghz->txrx) == SubGhzPresetHopperStateOFF) {
+        return 0;
+    } else {
+        variable_item_set_current_value_text(
+            variable_item_list_get(subghz->variable_item_list, SubGhzSettingIndexModulation),
+            " -----");
+        return value_index_float(
+            subghz->last_settings->preset_hopping_threshold,
+            preset_hopping_mode_value,
+            PRESET_HOPPING_MODE_COUNT);
+    }
+}
+
 uint8_t subghz_scene_receiver_config_hopper_value_index(void* context) {
     furi_assert(context);
     SubGhz* subghz = context;
@@ -213,19 +261,21 @@ static void subghz_scene_receiver_config_set_preset(VariableItem* item) {
     uint8_t index = variable_item_get_current_value_index(item);
     SubGhzSetting* setting = subghz_txrx_get_setting(subghz->txrx);
 
-    const char* preset_name = subghz_setting_get_preset_name(setting, index);
-    variable_item_set_current_value_text(item, preset_name);
-    //subghz->last_settings->preset = index;
-    SubGhzRadioPreset preset = subghz_txrx_get_preset(subghz->txrx);
-    uint8_t* preset_data = subghz_setting_get_preset_data(setting, index);
-    size_t preset_data_size = subghz_setting_get_preset_data_size(setting, index);
+    if(subghz_txrx_preset_hopper_get_state(subghz->txrx) == SubGhzPresetHopperStateOFF) {
+        const char* preset_name = subghz_setting_get_preset_name(setting, index);
+        variable_item_set_current_value_text(item, preset_name);
+        SubGhzRadioPreset preset = subghz_txrx_get_preset(subghz->txrx);
+        uint8_t* preset_data = subghz_setting_get_preset_data(setting, index);
+        size_t preset_data_size = subghz_setting_get_preset_data_size(setting, index);
 
-    //Edit TX power, if necessary.
-    subghz_txrx_set_tx_power(preset_data, preset_data_size, subghz->tx_power);
+        subghz_txrx_set_tx_power(preset_data, preset_data_size, subghz->tx_power);
 
-    subghz_txrx_set_preset(
-        subghz->txrx, preset_name, preset.frequency, preset_data, preset_data_size);
-    subghz->last_settings->preset_index = index;
+        subghz_txrx_set_preset(
+            subghz->txrx, preset_name, preset.frequency, preset_data, preset_data_size);
+        subghz->last_settings->preset_index = index;
+    } else {
+        variable_item_set_current_value_index(item, subghz->last_settings->preset_index);
+    }
 }
 
 static void subghz_scene_receiver_config_set_hopping(VariableItem* item) {
@@ -274,15 +324,57 @@ static void subghz_scene_receiver_config_set_hopping(VariableItem* item) {
     subghz->last_settings->hopping_threshold = hopping_mode_value[index];
     subghz_txrx_hopper_set_state(
         subghz->txrx, index != 0 ? SubGhzHopperStateRunning : SubGhzHopperStateOFF);
+
+    VariableItem* preset_hopping_item =
+        variable_item_list_get(subghz->variable_item_list, SubGhzSettingIndexPresetHopping);
+    variable_item_set_locked(
+        preset_hopping_item,
+        index != 0,
+        "Turn off\nHopping\nfirst!");
 }
 
-static void subghz_scene_receiver_config_set_mod_hopping(VariableItem* item) {
+static void subghz_scene_receiver_config_set_preset_hopping(VariableItem* item) {
     SubGhz* subghz = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
-    variable_item_set_current_value_text(item, combobox_text[index]);
-    bool enabled = index == 1;
-    subghz->last_settings->enable_mod_hopping = enabled;
-    subghz_txrx_mod_hopper_set_running(subghz->txrx, enabled);
+    SubGhzSetting* setting = subghz_txrx_get_setting(subghz->txrx);
+    VariableItem* preset_item =
+        variable_item_list_get(subghz->variable_item_list, SubGhzSettingIndexModulation);
+
+    variable_item_set_current_value_text(item, preset_hopping_mode_text[index]);
+
+    if(index == 0) {
+        SubGhzRadioPreset current_preset = subghz_txrx_get_preset(subghz->txrx);
+        const char* current_preset_name = furi_string_get_cstr(current_preset.name);
+        int current_preset_index = subghz_setting_get_inx_preset_by_name(setting, current_preset_name);
+        if(current_preset_index >= 0) {
+            subghz->last_settings->preset_index = current_preset_index;
+        }
+        variable_item_set_current_value_text(preset_item, current_preset_name);
+        variable_item_set_current_value_index(preset_item, subghz->last_settings->preset_index);
+
+        subghz->last_settings->enable_preset_hopping = false;
+        subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateOFF);
+    } else {
+        bool was_running = (subghz_txrx_preset_hopper_get_state(subghz->txrx) == SubGhzPresetHopperStateRunning);
+        if(was_running) {
+            subghz_txrx_preset_hopper_pause(subghz->txrx);
+        }
+
+        subghz->last_settings->preset_hopping_threshold = preset_hopping_mode_value[index];
+
+        variable_item_set_current_value_text(preset_item, " -----");
+        variable_item_set_current_value_index(preset_item, subghz->last_settings->preset_index);
+
+        subghz->last_settings->enable_preset_hopping = true;
+        subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateRunning);
+    }
+
+    VariableItem* hopping_item =
+        variable_item_list_get(subghz->variable_item_list, SubGhzSettingIndexHopping);
+    variable_item_set_locked(
+        hopping_item,
+        index != 0,
+        "Turn off\nPreset\nHopping\nfirst!");
 }
 
 static void subghz_scene_receiver_config_set_speaker(VariableItem* item) {
@@ -385,8 +477,9 @@ static void subghz_scene_receiver_config_var_list_enter_callback(void* context,
 
         subghz_txrx_hopper_set_state(subghz->txrx, hopping_value[default_index]);
         subghz->last_settings->enable_hopping = hopping_value[default_index];
-        subghz->last_settings->enable_mod_hopping = false;
-        subghz_txrx_mod_hopper_set_running(subghz->txrx, false);
+        subghz->last_settings->enable_preset_hopping = false;
+        subghz->last_settings->preset_hopping_threshold = SUBGHZ_LAST_SETTING_DEFAULT_PRESET_HOPPING_THRESHOLD;
+        subghz_txrx_preset_hopper_set_state(subghz->txrx, SubGhzPresetHopperStateOFF);
 
         variable_item_list_set_selected_item(subghz->variable_item_list, default_index);
         variable_item_list_reset(subghz->variable_item_list);
@@ -451,16 +544,26 @@ void subghz_scene_receiver_config_on_enter(void* context) {
         variable_item_set_current_value_index(item, value_index);
         variable_item_set_current_value_text(item, hopping_mode_text[value_index]);
 
-        // Mod Hopping
+        variable_item_set_locked(
+            item,
+            subghz_txrx_preset_hopper_get_state(subghz->txrx) != SubGhzPresetHopperStateOFF,
+            "Turn off\nPreset\nHopping\nfirst!");
+
+        value_index = subghz_scene_receiver_config_preset_hopper_value_index(subghz);
         item = variable_item_list_add(
             subghz->variable_item_list,
-            "Mod Hopping",
-            COMBO_BOX_COUNT,
-            subghz_scene_receiver_config_set_mod_hopping,
+            "Preset Hopping",
+            PRESET_HOPPING_MODE_COUNT,
+            subghz_scene_receiver_config_set_preset_hopping,
             subghz);
-        value_index = subghz->last_settings->enable_mod_hopping ? 1 : 0;
+
         variable_item_set_current_value_index(item, value_index);
-        variable_item_set_current_value_text(item, combobox_text[value_index]);
+        variable_item_set_current_value_text(item, preset_hopping_mode_text[value_index]);
+
+        variable_item_set_locked(
+            item,
+            subghz_txrx_hopper_get_state(subghz->txrx) != SubGhzHopperStateOFF,
+            "Turn off\nHopping\nfirst!");
     }
 
     if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=

applications/main/subghz/subghz_last_settings.c

@@ -13,7 +13,8 @@
 #define SUBGHZ_LAST_SETTING_FIELD_FREQUENCY_ANALYZER_TRIGGER        "FATrigger"
 #define SUBGHZ_LAST_SETTING_FIELD_PROTOCOL_FILE_NAMES               "ProtocolNames"
 #define SUBGHZ_LAST_SETTING_FIELD_HOPPING_ENABLE                    "Hopping"
-#define SUBGHZ_LAST_SETTING_FIELD_MOD_HOPPING                       "ModHopping"
+#define SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING                     "PresetHopping"
+#define SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING_THRESHOLD          "PresetHoppingThreshold"
 #define SUBGHZ_LAST_SETTING_FIELD_IGNORE_FILTER                     "IgnoreFilter"
 #define SUBGHZ_LAST_SETTING_FIELD_FILTER                            "Filter"
 #define SUBGHZ_LAST_SETTING_FIELD_RSSI_THRESHOLD                    "RSSI"
@@ -46,6 +47,8 @@ void subghz_last_settings_load(SubGhzLastSettings* instance, size_t preset_count
     instance->filter = SubGhzProtocolFlag_Decodable;
     instance->rssi = SUBGHZ_RAW_THRESHOLD_MIN;
     instance->hopping_threshold = -90.0f;
+    instance->enable_preset_hopping = false;
+    instance->preset_hopping_threshold = SUBGHZ_LAST_SETTING_DEFAULT_PRESET_HOPPING_THRESHOLD;
     instance->leds_and_amp = true;
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
@@ -101,11 +104,23 @@ void subghz_last_settings_load(SubGhzLastSettings* instance, size_t preset_count
             }
             if(!flipper_format_read_bool(
                    fff_data_file,
-                   SUBGHZ_LAST_SETTING_FIELD_MOD_HOPPING,
-                   &instance->enable_mod_hopping,
+                   SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING,
+                   &instance->enable_preset_hopping,
                    1)) {
+                instance->enable_preset_hopping = false;
                 flipper_format_rewind(fff_data_file);
             }
+            float temp_preset_threshold = 0;
+            if(!flipper_format_read_float(
+                   fff_data_file,
+                   SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING_THRESHOLD,
+                   &temp_preset_threshold,
+                   1)) {
+                instance->preset_hopping_threshold = SUBGHZ_LAST_SETTING_DEFAULT_PRESET_HOPPING_THRESHOLD;
+                flipper_format_rewind(fff_data_file);
+            } else {
+                instance->preset_hopping_threshold = temp_preset_threshold;
+            }
             if(!flipper_format_read_uint32(
                    fff_data_file,
                    SUBGHZ_LAST_SETTING_FIELD_IGNORE_FILTER,
@@ -223,8 +238,15 @@ bool subghz_last_settings_save(SubGhzLastSettings* instance) {
         }
         if(!flipper_format_write_bool(
                file,
-               SUBGHZ_LAST_SETTING_FIELD_MOD_HOPPING,
-               &instance->enable_mod_hopping,
+               SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING,
+               &instance->enable_preset_hopping,
+               1)) {
+            break;
+        }
+        if(!flipper_format_write_float(
+               file,
+               SUBGHZ_LAST_SETTING_FIELD_PRESET_HOPPING_THRESHOLD,
+               &instance->preset_hopping_threshold,
                1)) {
             break;
         }

applications/main/subghz/subghz_last_settings.h

@@ -12,20 +12,22 @@
 #define SUBGHZ_LAST_SETTING_DEFAULT_PRESET                    1
 #define SUBGHZ_LAST_SETTING_DEFAULT_FREQUENCY                 433920000
 #define SUBGHZ_LAST_SETTING_FREQUENCY_ANALYZER_FEEDBACK_LEVEL 2
+#define SUBGHZ_LAST_SETTING_DEFAULT_PRESET_HOPPING_THRESHOLD  (-80.0f)
 
 typedef struct {
     uint32_t frequency;
-    uint32_t preset_index; // AKA Modulation
+    uint32_t preset_index;
     uint32_t frequency_analyzer_feedback_level;
     float frequency_analyzer_trigger;
     bool protocol_file_names;
     bool enable_hopping;
-    bool enable_mod_hopping;
     uint32_t ignore_filter;
     uint32_t filter;
     float rssi;
     bool delete_old_signals;
     float hopping_threshold;
+    bool enable_preset_hopping;
+    float preset_hopping_threshold;
     bool leds_and_amp;
     uint8_t tx_power;
 } SubGhzLastSettings;

applications/services/desktop/scenes/desktop_scene_slideshow.c

@@ -1,4 +1,5 @@
 #include <storage/storage.h>
+#include <gui/gui.h>
 
 #include "../desktop_i.h"
 #include "../views/desktop_view_slideshow.h"
@@ -14,6 +15,7 @@ void desktop_scene_slideshow_on_enter(void* context) {
     Desktop* desktop = (Desktop*)context;
     DesktopSlideshowView* slideshow_view = desktop->slideshow_view;
 
+    gui_set_hide_status_bar(desktop->gui, true);
     desktop_view_slideshow_set_callback(slideshow_view, desktop_scene_slideshow_callback, desktop);
 
     view_dispatcher_switch_to_view(desktop->view_dispatcher, DesktopViewIdSlideshow);
@@ -46,5 +48,6 @@ bool desktop_scene_slideshow_on_event(void* context, SceneManagerEvent event) {
 
 void desktop_scene_slideshow_on_exit(void* context) {
     Desktop* desktop = context;
+    gui_set_hide_status_bar(desktop->gui, false);
     storage_common_remove(desktop->storage, SLIDESHOW_FS_PATH);
 }

applications/services/gui/gui.c

@@ -251,16 +251,20 @@ static void gui_redraw(Gui* gui) {
 
         if(gui_is_lockdown(gui)) {
             gui_redraw_desktop(gui);
-            bool need_attention =
-                (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 ||
-                 gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0);
-            gui_redraw_status_bar(gui, need_attention);
+            if(!gui->hide_status_bar) {
+                bool need_attention =
+                    (gui_view_port_find_enabled(gui->layers[GuiLayerWindow]) != 0 ||
+                     gui_view_port_find_enabled(gui->layers[GuiLayerFullscreen]) != 0);
+                gui_redraw_status_bar(gui, need_attention);
+            }
         } else {
             if(!gui_redraw_fs(gui)) {
                 if(!gui_redraw_window(gui)) {
                     gui_redraw_desktop(gui);
                 }
-                gui_redraw_status_bar(gui, false);
+                if(!gui->hide_status_bar) {
+                    gui_redraw_status_bar(gui, false);
+                }
             }
         }
 
@@ -512,6 +516,16 @@ bool gui_is_lockdown(const Gui* gui) {
     return gui->lockdown && !gui->lockdown_inhibit;
 }
 
+void gui_set_hide_status_bar(Gui* gui, bool hide) {
+    furi_check(gui);
+
+    gui_lock(gui);
+    gui->hide_status_bar = hide;
+    gui_unlock(gui);
+
+    gui_update(gui);
+}
+
 Canvas* gui_direct_draw_acquire(Gui* gui) {
     furi_check(gui);
 

applications/services/gui/gui.h

@@ -127,6 +127,16 @@ void gui_set_lockdown_inhibit(Gui* gui, bool inhibit);
  */
 bool gui_is_lockdown(const Gui* gui);
 
+/** Set hide status bar mode
+ *
+ * When enabled, the status bar is not drawn on top of the desktop layer.
+ * Used by the slideshow to show fullscreen content without the status bar overlay.
+ *
+ * @param      gui   Gui instance
+ * @param      hide  bool, true to hide status bar
+ */
+void gui_set_hide_status_bar(Gui* gui, bool hide);
+
 /** Acquire Direct Draw lock and get Canvas instance
  *
  * This method return Canvas instance for use in monopoly mode. Direct draw lock

applications/services/gui/gui_i.h

@@ -53,6 +53,7 @@ struct Gui {
     bool lockdown;
     bool lockdown_inhibit;
     bool direct_draw;
+    bool hide_status_bar;
     ViewPortArray_t layers[GuiLayerMAX];
     Canvas* canvas;
 

applications_user/FlipperPrinceOfArabia/.github/workflows/build_release.yml

@@ -1,108 +0,0 @@
-name: FAP Build & Auto Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-permissions:
-  contents: write
-
-concurrency:
-  group: auto-release-${{ github.ref }}
-  cancel-in-progress: false
-
-jobs:
-  build-and-release:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          repository: flipperdevices/flipperzero-firmware
-          ref: dev
-          path: firmware
-          submodules: recursive
-
-      - uses: actions/checkout@v4
-        with:
-          path: firmware/applications_user/app
-          fetch-depth: 0
-          submodules: recursive
-
-      - id: manifest
-        shell: bash
-        run: |
-          set -euo pipefail
-          MANIFEST_PATH="firmware/applications_user/app/application.fam"
-
-          if [ ! -f "$MANIFEST_PATH" ]; then
-            echo "application.fam not found in firmware/applications_user/app/" >&2
-            exit 1
-          fi
-
-          mapfile -t APP_IDS < <(sed -n 's/^[[:space:]]*appid="\([^"]\+\)".*/\1/p' "$MANIFEST_PATH")
-          if [ "${#APP_IDS[@]}" -eq 0 ]; then
-            echo "No appid entries found in $MANIFEST_PATH" >&2
-            exit 1
-          fi
-
-          BUILD_TARGETS=()
-          for APP_ID in "${APP_IDS[@]}"; do
-            BUILD_TARGETS+=("fap_${APP_ID}")
-          done
-
-          {
-            printf 'build_targets=%s\n' "${BUILD_TARGETS[*]}"
-            echo 'app_ids<<EOF'
-            printf '%s\n' "${APP_IDS[@]}"
-            echo 'EOF'
-          } >> "$GITHUB_OUTPUT"
-
-      - shell: bash
-        working-directory: firmware
-        run: |
-          set -euo pipefail
-          ./fbt ${{ steps.manifest.outputs.build_targets }}
-
-      - shell: bash
-        run: |
-          set -euo pipefail
-          mkdir -p artifacts
-          while IFS= read -r APP_ID; do
-            [ -n "$APP_ID" ] || continue
-            find firmware/build -type f -name "${APP_ID}.fap" -exec cp {} artifacts/ \;
-          done <<'EOF'
-          ${{ steps.manifest.outputs.app_ids }}
-          EOF
-
-          if ! find artifacts -maxdepth 1 -type f -name '*.fap' | grep -q .; then
-            echo "No FAP artifacts were collected" >&2
-            exit 1
-          fi
-
-          ls -l artifacts
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ${{ github.event.repository.name }}-${{ github.ref_name }}
-          path: artifacts/*.fap
-
-      - env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          TAG="${{ github.ref_name }}"
-
-          if gh release view "$TAG" --repo "$GH_REPO" >/dev/null 2>&1; then
-            echo "Release already exists"
-            exit 0
-          fi
-
-          gh release create "$TAG" \
-            --repo "$GH_REPO" \
-            --title "$TAG" \
-            --notes "Automated build from ${{ github.sha }}" \
-            artifacts/*.fap

applications_user/FlipperPrinceOfArabia/.gitignore

@@ -1,4 +0,0 @@
-libraries/
-.DS_Store
-.vscode
-venv

applications_user/FlipperPrinceOfArabia/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "lib"]
-	path = lib
-	url = https://github.com/apfxtech/arduboylib.git

applications_user/FlipperPrinceOfArabia/APPSTORE.md

@@ -1,23 +0,0 @@
-**Your Quest**
-Escape the treacherous dungeons, battle fierce enemies, and rescue the imprisoned princess in this action-packed platformer brought to you by Press-Play-On-Tape.
-
-**Features**
-
-- **13 challenging levels** — Navigate through an intricate palace filled with deadly traps and hidden secrets
-- **Dynamic combat system** — Find your sword and duel against guards, skeletons, and shadowy figures
-- **Acrobatic gameplay** — Run, jump, climb, and perform daring acrobatic moves to overcome obstacles
-- **Interactive environment** — Trigger floor switches, avoid falling tiles, and escape collapsing platforms
-- **Mysterious potions** — Drink carefully! Some restore life, others may cost you dearly
-- **Save system** — Save your progress at any time via the in-game menu
-- **Easter egg** — Discover the hidden arcade game within the palace
-
-**Enemies Await**
-Face off against palace guards, undead skeletons, and mysterious shadowy figures that lurk in the forbidden corridors.
-
-Can you master all 13 levels and free the princess?
-
-Concept   Jordan Mechner
-Code      @filmote @Mr.Blinky @acedent
-Graphics  @clintonium-119 @vampirics
-Music     @raspberrybrain
-Ported    @apfxtech

applications_user/FlipperPrinceOfArabia/CHANGELOG.md

@@ -1,2 +0,0 @@
-v1.0:
-app release

applications_user/FlipperPrinceOfArabia/LICENSE

@@ -1,106 +0,0 @@
-FlipperPrinceOfArabia License and Distribution Terms
-
-Copyright (c) 2026 Apfxtech
-
-This repository contains a Flipper Zero port related to the project
-"Press-Play-On-Tape/PrinceOfArabia". Not all material in this repository is
-distributed under the same terms.
-
-Read this entire file before using, modifying, distributing, or redistributing
-this repository or any binary built from it.
-
-1. Definitions
-
-"Original Contributions" means code, build glue, Flipper Zero integration,
-repository metadata, packaging, documentation, and other material authored by
-Apfxtech to the extent Apfxtech owns the relevant copyright.
-
-"Upstream-Derived Materials" means any code, assets, level data, music, images,
-text, gameplay data, or other material copied from, adapted from, based on, or
-otherwise derived from PrinceOfArabia or other non-Apfxtech sources.
-
-"Third-Party Components" means material in this repository that is provided
-under its own separate license or notice.
-
-2. License for Apfxtech Original Contributions
-
-Except for Upstream-Derived Materials, Third-Party Components, trademarks, trade
-dress, and any other rights not expressly granted, Apfxtech licenses the
-Original Contributions under the BSD 3-Clause License reproduced below.
-
-BSD 3-Clause License
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-3. Terms for Upstream-Derived Materials
-
-Upstream-Derived Materials are not relicensed by Apfxtech under BSD 3-Clause.
-
-Upstream-Derived Materials included in this repository or in binaries built from
-this repository are distributed only under separate permission limited to the
-Flipper Zero platform.
-
-Accordingly, unless you have additional permission directly from the relevant
-rights holders, you may not:
-
-1. redistribute Upstream-Derived Materials for Arduboy or any platform other
-   than Flipper Zero;
-2. use this file as a basis to claim that the whole repository or the whole
-   binary is open source;
-3. remove the platform limitation applicable to Upstream-Derived Materials; or
-4. sublicense Upstream-Derived Materials under BSD 3-Clause, MIT, GPL, or any
-   other open-source license.
-
-If you redistribute a source tree, release archive, package, or binary
-containing Upstream-Derived Materials, that redistribution is authorized only
-for Flipper Zero versions of this project and only together with this license
-file and any other applicable notices.
-
-4. Combined Source Trees and Binaries
-
-This repository and its build outputs may contain both:
-
-1. Original Contributions licensed under BSD 3-Clause; and
-2. Upstream-Derived Materials distributed only for Flipper Zero under separate
-   permission.
-
-For that reason, the repository as a whole, and binaries as a whole, must not
-be described as being entirely under BSD 3-Clause or any other single
-open-source license.
-
-5. Third-Party Components
-
-Third-Party Components keep their own license terms. Those terms apply in
-addition to this file where relevant.
-6. No Trademark License
-
-No trademark or trade dress rights are granted by this file.
-
-7. If You Need Broader Rights
-
-If you need rights broader than those granted above, including rights to use or
-redistribute Upstream-Derived Materials outside the Flipper Zero platform, you
-must obtain permission from the relevant rights holders.

applications_user/FlipperPrinceOfArabia/README.md

@@ -1,61 +0,0 @@
-# FlipperPrinceOfArabia
-
-Inspired by a timeless classic, Press-Play-On-Tape presents 'Prince of Arabia'!
-Escape the dungeons and free the princess!
-
-![s1](package/distributable/Level1RunThroughX2.gif)
-
-## Controls
-
-<kbd>🅐</kbd>
-<kbd>🅑</kbd>
-<kbd>▲</kbd>
-<kbd>▼</kbd>
-<kbd>◄</kbd>
-<kbd>►</kbd>
-
-**Running**
-
-**Jumping** — Press <kbd>🅐</kbd> to jump over obstacles. For longer jumps, run and jump <kbd>🅐</kbd>+<kbd>◄</kbd>/<kbd>►</kbd>.
-
-**Climbing**
-
-**Dropping** — Drop and pull-up.
-
-**Squatting** — Ducking down. Shuffling along.
-
-**In game menu** — Press <kbd>🅑</kbd> to select the in game menu. This allows you to...
-
-## Objects
-
-**Sword** — Crouch down and pickup with <kbd>🅐</kbd> to collect the sword. When an enemy appears, press <kbd>🅑</kbd> to unsheathe the sword and start fighting. It is not possible to bring-up the menu (or save the game!) during a fight. During a fight, press <kbd>🅐</kbd> to sheath sword. It is not possible to jump while the sword is drawn.
-
-**Potions** — Crouch down and pickup with 'A' to drink. Some give life, but some may take life!
-
-## Navigating the palace
-
-**Floor switches** — Open/closing. To activate stand on a tile, or some weight must be applied. Switches may reset after a certain amount of time.
-
-**Falling tiles** — Step on (from above). Can be triggered from below.
-
-**Deadly spikes** — Jump over these traps or move very carefully to avoid a spiky end!
-
-## Enemies
-
-- **Guards**
-- **Skeletons**
-- **Shadowy figures** — Legend tells, that these forbidden corridors will reveal our darkest side.
-
-## Credits
-Concept: Jordan Mechner.  
-Development: @filmote, @MrBlinky (/Mr.Blinky), @ace-dent (/acedent)  
-Graphics: /clintonium-119, @vampirics  
-Music: @ajsaucier (/raspberrybrain)  
-Flipper port: @apfxtech
-
-## Licensing
-This project uses mixed licensing and distribution terms.
-Read the root [LICENSE](LICENSE) in full before using.
-
-# Original
-**Press-Play-On-Tape** [Prince of Arabia](https://github.com/Press-Play-On-Tape/PrinceOfArabia.git)

applications_user/FlipperPrinceOfArabia/application.fam

@@ -1,47 +0,0 @@
-SOURCES = [
-    "main.cpp",
-    "game/ArduboyFX.cpp",
-    "src/ArduboyTonesFX.cpp",
-    "src/utils/Arduboy2Ext.cpp",
-    "src/fonts/Font3x5.cpp",
-    "lib/scr/*.cpp",
-]
-
-CDEFINES_BASE = [
-    "ARDULIB_USE_FX",
-    "ARDULIB_USE_TONES",
-    "ARDULIB_SWAP_AB",
-]
-
-CDEFINES_EX = CDEFINES_BASE + ["ARDULIB_USE_VIEW_PORT"]
-
-COMMON_ARGS = {
-    "apptype": FlipperAppType.EXTERNAL,
-    "entry_point": "arduboy_app",
-    "sources": SOURCES,
-    "requires": ["gui"],
-    "stack_size": 8 * 1024,
-    "fap_category": "Games",
-    "fap_icon": "icon.png",
-    "order": 36,
-    "fap_author": "@apfxtech",
-    "fap_weburl": "https://github.com/apfxtech/FlipperPrinceOfArabia.git",
-    "fap_version": "1.0",
-    "fap_description": "Escape the dungeons and free the princess!",
-}
-
-App(
-    appid="princeofarabia",
-    name="Prince Of Arabia",
-    cdefines=CDEFINES_BASE,
-    fap_file_assets="assets/POA",
-    **COMMON_ARGS
-)
-
-App(
-    appid="princeofarabia_ex",
-    name="Prince Of Arabia Experemental",
-    cdefines=CDEFINES_EX,
-    fap_file_assets="assets/POA",
-    **COMMON_ARGS
-)

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/LICENSE

@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
-    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
-    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
-    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
-    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
-    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
-    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
-    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
-    HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display,
-     communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
-     likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
-     subject to the limitations in paragraph 4(a), below;
-  v. rights protecting the extraction, dissemination, use and reuse of data
-     in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
-     European Parliament and of the Council of 11 March 1996 on the legal
-     protection of databases, and under any national implementation
-     thereof, including any amended or successor version of such
-     directive); and
-vii. other similar, equivalent or corresponding rights throughout the
-     world based on applicable law or treaty, and any national
-     implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
-    surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
-    warranties of any kind concerning the Work, express, implied,
-    statutory or otherwise, including without limitation warranties of
-    title, merchantability, fitness for a particular purpose, non
-    infringement, or the absence of latent or other defects, accuracy, or
-    the present or absence of errors, whether or not discoverable, all to
-    the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
-    that may apply to the Work or any use thereof, including without
-    limitation any person's Copyright and Related Rights in the Work.
-    Further, Affirmer disclaims responsibility for obtaining any necessary
-    consents, permissions or other rights required for any use of the
-    Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
-    party to this document and has no duty or obligation with respect to
-    this CC0 or use of the Work.

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/BdfFontFile.py

@@ -1,110 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# bitmap distribution font (bdf) file parser
-#
-# history:
-# 1996-05-16 fl   created (as bdf2pil)
-# 1997-08-25 fl   converted to FontFile driver
-# 2001-05-25 fl   removed bogus __init__ call
-# 2002-11-20 fl   robustification (from Kevin Cazabon, Dmitry Vasiliev)
-# 2003-04-22 fl   more robustification (from Graham Dumpleton)
-#
-# Copyright (c) 1997-2003 by Secret Labs AB.
-# Copyright (c) 1997-2003 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-"""
-Parse X Bitmap Distribution Format (BDF)
-"""
-
-
-from . import FontFile, Image
-
-bdf_slant = {
-    "R": "Roman",
-    "I": "Italic",
-    "O": "Oblique",
-    "RI": "Reverse Italic",
-    "RO": "Reverse Oblique",
-    "OT": "Other",
-}
-
-bdf_spacing = {"P": "Proportional", "M": "Monospaced", "C": "Cell"}
-
-
-def bdf_char(f):
-    # skip to STARTCHAR
-    while True:
-        s = f.readline()
-        if not s:
-            return None
-        if s[:9] == b"STARTCHAR":
-            break
-    id = s[9:].strip().decode("ascii")
-
-    # load symbol properties
-    props = {}
-    while True:
-        s = f.readline()
-        if not s or s[:6] == b"BITMAP":
-            break
-        i = s.find(b" ")
-        props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
-
-    # load bitmap
-    bitmap = []
-    while True:
-        s = f.readline()
-        if not s or s[:7] == b"ENDCHAR":
-            break
-        bitmap.append(s[:-1])
-    bitmap = b"".join(bitmap)
-
-    [x, y, l, d] = [int(p) for p in props["BBX"].split()]
-    [dx, dy] = [int(p) for p in props["DWIDTH"].split()]
-
-    bbox = (dx, dy), (l, -d - y, x + l, -d), (0, 0, x, y)
-
-    try:
-        im = Image.frombytes("1", (x, y), bitmap, "hex", "1")
-    except ValueError:
-        # deal with zero-width characters
-        im = Image.new("1", (x, y))
-
-    return id, int(props["ENCODING"]), bbox, im
-
-
-class BdfFontFile(FontFile.FontFile):
-    """Font file plugin for the X11 BDF format."""
-
-    def __init__(self, fp):
-        super().__init__()
-
-        s = fp.readline()
-        if s[:13] != b"STARTFONT 2.1":
-            raise SyntaxError("not a valid BDF file")
-
-        props = {}
-        comments = []
-
-        while True:
-            s = fp.readline()
-            if not s or s[:13] == b"ENDPROPERTIES":
-                break
-            i = s.find(b" ")
-            props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
-            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
-                if s.find(b"LogicalFontDescription") < 0:
-                    comments.append(s[i + 1 : -1].decode("ascii"))
-
-        while True:
-            c = bdf_char(fp)
-            if not c:
-                break
-            id, ch, (xy, dst, src), im = c
-            if 0 <= ch < len(self.glyph):
-                self.glyph[ch] = xy, dst, src, im

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/BlpImagePlugin.py

@@ -1,484 +0,0 @@
-"""
-Blizzard Mipmap Format (.blp)
-Jerome Leclanche <jerome@leclan.ch>
-
-The contents of this file are hereby released in the public domain (CC0)
-Full text of the CC0 license:
-  https://creativecommons.org/publicdomain/zero/1.0/
-
-BLP1 files, used mostly in Warcraft III, are not fully supported.
-All types of BLP2 files used in World of Warcraft are supported.
-
-The BLP file structure consists of a header, up to 16 mipmaps of the
-texture
-
-Texture sizes must be powers of two, though the two dimensions do
-not have to be equal; 512x256 is valid, but 512x200 is not.
-The first mipmap (mipmap #0) is the full size image; each subsequent
-mipmap halves both dimensions. The final mipmap should be 1x1.
-
-BLP files come in many different flavours:
-* JPEG-compressed (type == 0) - only supported for BLP1.
-* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
-  array of 8-bit values, one per pixel, left to right, top to bottom.
-  Each value is an index to the palette.
-* DXT-compressed (type == 1, encoding == 2):
-- DXT1 compression is used if alpha_encoding == 0.
-  - An additional alpha bit is used if alpha_depth == 1.
-  - DXT3 compression is used if alpha_encoding == 1.
-  - DXT5 compression is used if alpha_encoding == 7.
-"""
-
-import os
-import struct
-from enum import IntEnum
-from io import BytesIO
-
-from . import Image, ImageFile
-from ._deprecate import deprecate
-
-
-class Format(IntEnum):
-    JPEG = 0
-
-
-class Encoding(IntEnum):
-    UNCOMPRESSED = 1
-    DXT = 2
-    UNCOMPRESSED_RAW_BGRA = 3
-
-
-class AlphaEncoding(IntEnum):
-    DXT1 = 0
-    DXT3 = 1
-    DXT5 = 7
-
-
-def __getattr__(name):
-    for enum, prefix in {
-        Format: "BLP_FORMAT_",
-        Encoding: "BLP_ENCODING_",
-        AlphaEncoding: "BLP_ALPHA_ENCODING_",
-    }.items():
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            if name in enum.__members__:
-                deprecate(f"{prefix}{name}", 10, f"{enum.__name__}.{name}")
-                return enum[name]
-    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-def unpack_565(i):
-    return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
-
-
-def decode_dxt1(data, alpha=False):
-    """
-    input: one "row" of data (i.e. will produce 4*width pixels)
-    """
-
-    blocks = len(data) // 8  # number of blocks in row
-    ret = (bytearray(), bytearray(), bytearray(), bytearray())
-
-    for block in range(blocks):
-        # Decode next 8-byte block.
-        idx = block * 8
-        color0, color1, bits = struct.unpack_from("<HHI", data, idx)
-
-        r0, g0, b0 = unpack_565(color0)
-        r1, g1, b1 = unpack_565(color1)
-
-        # Decode this block into 4x4 pixels
-        # Accumulate the results onto our 4 row accumulators
-        for j in range(4):
-            for i in range(4):
-                # get next control op and generate a pixel
-
-                control = bits & 3
-                bits = bits >> 2
-
-                a = 0xFF
-                if control == 0:
-                    r, g, b = r0, g0, b0
-                elif control == 1:
-                    r, g, b = r1, g1, b1
-                elif control == 2:
-                    if color0 > color1:
-                        r = (2 * r0 + r1) // 3
-                        g = (2 * g0 + g1) // 3
-                        b = (2 * b0 + b1) // 3
-                    else:
-                        r = (r0 + r1) // 2
-                        g = (g0 + g1) // 2
-                        b = (b0 + b1) // 2
-                elif control == 3:
-                    if color0 > color1:
-                        r = (2 * r1 + r0) // 3
-                        g = (2 * g1 + g0) // 3
-                        b = (2 * b1 + b0) // 3
-                    else:
-                        r, g, b, a = 0, 0, 0, 0
-
-                if alpha:
-                    ret[j].extend([r, g, b, a])
-                else:
-                    ret[j].extend([r, g, b])
-
-    return ret
-
-
-def decode_dxt3(data):
-    """
-    input: one "row" of data (i.e. will produce 4*width pixels)
-    """
-
-    blocks = len(data) // 16  # number of blocks in row
-    ret = (bytearray(), bytearray(), bytearray(), bytearray())
-
-    for block in range(blocks):
-        idx = block * 16
-        block = data[idx : idx + 16]
-        # Decode next 16-byte block.
-        bits = struct.unpack_from("<8B", block)
-        color0, color1 = struct.unpack_from("<HH", block, 8)
-
-        (code,) = struct.unpack_from("<I", block, 12)
-
-        r0, g0, b0 = unpack_565(color0)
-        r1, g1, b1 = unpack_565(color1)
-
-        for j in range(4):
-            high = False  # Do we want the higher bits?
-            for i in range(4):
-                alphacode_index = (4 * j + i) // 2
-                a = bits[alphacode_index]
-                if high:
-                    high = False
-                    a >>= 4
-                else:
-                    high = True
-                    a &= 0xF
-                a *= 17  # We get a value between 0 and 15
-
-                color_code = (code >> 2 * (4 * j + i)) & 0x03
-
-                if color_code == 0:
-                    r, g, b = r0, g0, b0
-                elif color_code == 1:
-                    r, g, b = r1, g1, b1
-                elif color_code == 2:
-                    r = (2 * r0 + r1) // 3
-                    g = (2 * g0 + g1) // 3
-                    b = (2 * b0 + b1) // 3
-                elif color_code == 3:
-                    r = (2 * r1 + r0) // 3
-                    g = (2 * g1 + g0) // 3
-                    b = (2 * b1 + b0) // 3
-
-                ret[j].extend([r, g, b, a])
-
-    return ret
-
-
-def decode_dxt5(data):
-    """
-    input: one "row" of data (i.e. will produce 4 * width pixels)
-    """
-
-    blocks = len(data) // 16  # number of blocks in row
-    ret = (bytearray(), bytearray(), bytearray(), bytearray())
-
-    for block in range(blocks):
-        idx = block * 16
-        block = data[idx : idx + 16]
-        # Decode next 16-byte block.
-        a0, a1 = struct.unpack_from("<BB", block)
-
-        bits = struct.unpack_from("<6B", block, 2)
-        alphacode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
-        alphacode2 = bits[0] | (bits[1] << 8)
-
-        color0, color1 = struct.unpack_from("<HH", block, 8)
-
-        (code,) = struct.unpack_from("<I", block, 12)
-
-        r0, g0, b0 = unpack_565(color0)
-        r1, g1, b1 = unpack_565(color1)
-
-        for j in range(4):
-            for i in range(4):
-                # get next control op and generate a pixel
-                alphacode_index = 3 * (4 * j + i)
-
-                if alphacode_index <= 12:
-                    alphacode = (alphacode2 >> alphacode_index) & 0x07
-                elif alphacode_index == 15:
-                    alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
-                else:  # alphacode_index >= 18 and alphacode_index <= 45
-                    alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
-
-                if alphacode == 0:
-                    a = a0
-                elif alphacode == 1:
-                    a = a1
-                elif a0 > a1:
-                    a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
-                elif alphacode == 6:
-                    a = 0
-                elif alphacode == 7:
-                    a = 255
-                else:
-                    a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
-
-                color_code = (code >> 2 * (4 * j + i)) & 0x03
-
-                if color_code == 0:
-                    r, g, b = r0, g0, b0
-                elif color_code == 1:
-                    r, g, b = r1, g1, b1
-                elif color_code == 2:
-                    r = (2 * r0 + r1) // 3
-                    g = (2 * g0 + g1) // 3
-                    b = (2 * b0 + b1) // 3
-                elif color_code == 3:
-                    r = (2 * r1 + r0) // 3
-                    g = (2 * g1 + g0) // 3
-                    b = (2 * b1 + b0) // 3
-
-                ret[j].extend([r, g, b, a])
-
-    return ret
-
-
-class BLPFormatError(NotImplementedError):
-    pass
-
-
-def _accept(prefix):
-    return prefix[:4] in (b"BLP1", b"BLP2")
-
-
-class BlpImageFile(ImageFile.ImageFile):
-    """
-    Blizzard Mipmap Format
-    """
-
-    format = "BLP"
-    format_description = "Blizzard Mipmap Format"
-
-    def _open(self):
-        self.magic = self.fp.read(4)
-
-        self.fp.seek(5, os.SEEK_CUR)
-        (self._blp_alpha_depth,) = struct.unpack("<b", self.fp.read(1))
-
-        self.fp.seek(2, os.SEEK_CUR)
-        self._size = struct.unpack("<II", self.fp.read(8))
-
-        if self.magic in (b"BLP1", b"BLP2"):
-            decoder = self.magic.decode()
-        else:
-            raise BLPFormatError(f"Bad BLP magic {repr(self.magic)}")
-
-        self.mode = "RGBA" if self._blp_alpha_depth else "RGB"
-        self.tile = [(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
-
-
-class _BLPBaseDecoder(ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer):
-        try:
-            self._read_blp_header()
-            self._load()
-        except struct.error as e:
-            raise OSError("Truncated BLP file") from e
-        return -1, 0
-
-    def _read_blp_header(self):
-        self.fd.seek(4)
-        (self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
-
-        (self._blp_encoding,) = struct.unpack("<b", self._safe_read(1))
-        (self._blp_alpha_depth,) = struct.unpack("<b", self._safe_read(1))
-        (self._blp_alpha_encoding,) = struct.unpack("<b", self._safe_read(1))
-        self.fd.seek(1, os.SEEK_CUR)  # mips
-
-        self.size = struct.unpack("<II", self._safe_read(8))
-
-        if isinstance(self, BLP1Decoder):
-            # Only present for BLP1
-            (self._blp_encoding,) = struct.unpack("<i", self._safe_read(4))
-            self.fd.seek(4, os.SEEK_CUR)  # subtype
-
-        self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
-        self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
-
-    def _safe_read(self, length):
-        return ImageFile._safe_read(self.fd, length)
-
-    def _read_palette(self):
-        ret = []
-        for i in range(256):
-            try:
-                b, g, r, a = struct.unpack("<4B", self._safe_read(4))
-            except struct.error:
-                break
-            ret.append((b, g, r, a))
-        return ret
-
-    def _read_bgra(self, palette):
-        data = bytearray()
-        _data = BytesIO(self._safe_read(self._blp_lengths[0]))
-        while True:
-            try:
-                (offset,) = struct.unpack("<B", _data.read(1))
-            except struct.error:
-                break
-            b, g, r, a = palette[offset]
-            d = (r, g, b)
-            if self._blp_alpha_depth:
-                d += (a,)
-            data.extend(d)
-        return data
-
-
-class BLP1Decoder(_BLPBaseDecoder):
-    def _load(self):
-        if self._blp_compression == Format.JPEG:
-            self._decode_jpeg_stream()
-
-        elif self._blp_compression == 1:
-            if self._blp_encoding in (4, 5):
-                palette = self._read_palette()
-                data = self._read_bgra(palette)
-                self.set_as_raw(bytes(data))
-            else:
-                raise BLPFormatError(
-                    f"Unsupported BLP encoding {repr(self._blp_encoding)}"
-                )
-        else:
-            raise BLPFormatError(
-                f"Unsupported BLP compression {repr(self._blp_encoding)}"
-            )
-
-    def _decode_jpeg_stream(self):
-        from .JpegImagePlugin import JpegImageFile
-
-        (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
-        jpeg_header = self._safe_read(jpeg_header_size)
-        self._safe_read(self._blp_offsets[0] - self.fd.tell())  # What IS this?
-        data = self._safe_read(self._blp_lengths[0])
-        data = jpeg_header + data
-        data = BytesIO(data)
-        image = JpegImageFile(data)
-        Image._decompression_bomb_check(image.size)
-        r, g, b = image.convert("RGB").split()
-        image = Image.merge("RGB", (b, g, r))
-        self.set_as_raw(image.tobytes())
-
-
-class BLP2Decoder(_BLPBaseDecoder):
-    def _load(self):
-        palette = self._read_palette()
-
-        self.fd.seek(self._blp_offsets[0])
-
-        if self._blp_compression == 1:
-            # Uncompressed or DirectX compression
-
-            if self._blp_encoding == Encoding.UNCOMPRESSED:
-                data = self._read_bgra(palette)
-
-            elif self._blp_encoding == Encoding.DXT:
-                data = bytearray()
-                if self._blp_alpha_encoding == AlphaEncoding.DXT1:
-                    linesize = (self.size[0] + 3) // 4 * 8
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt1(
-                            self._safe_read(linesize), alpha=bool(self._blp_alpha_depth)
-                        ):
-                            data += d
-
-                elif self._blp_alpha_encoding == AlphaEncoding.DXT3:
-                    linesize = (self.size[0] + 3) // 4 * 16
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt3(self._safe_read(linesize)):
-                            data += d
-
-                elif self._blp_alpha_encoding == AlphaEncoding.DXT5:
-                    linesize = (self.size[0] + 3) // 4 * 16
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt5(self._safe_read(linesize)):
-                            data += d
-                else:
-                    raise BLPFormatError(
-                        f"Unsupported alpha encoding {repr(self._blp_alpha_encoding)}"
-                    )
-            else:
-                raise BLPFormatError(f"Unknown BLP encoding {repr(self._blp_encoding)}")
-
-        else:
-            raise BLPFormatError(
-                f"Unknown BLP compression {repr(self._blp_compression)}"
-            )
-
-        self.set_as_raw(bytes(data))
-
-
-class BLPEncoder(ImageFile.PyEncoder):
-    _pushes_fd = True
-
-    def _write_palette(self):
-        data = b""
-        palette = self.im.getpalette("RGBA", "RGBA")
-        for i in range(256):
-            r, g, b, a = palette[i * 4 : (i + 1) * 4]
-            data += struct.pack("<4B", b, g, r, a)
-        return data
-
-    def encode(self, bufsize):
-        palette_data = self._write_palette()
-
-        offset = 20 + 16 * 4 * 2 + len(palette_data)
-        data = struct.pack("<16I", offset, *((0,) * 15))
-
-        w, h = self.im.size
-        data += struct.pack("<16I", w * h, *((0,) * 15))
-
-        data += palette_data
-
-        for y in range(h):
-            for x in range(w):
-                data += struct.pack("<B", self.im.getpixel((x, y)))
-
-        return len(data), 0, data
-
-
-def _save(im, fp, filename, save_all=False):
-    if im.mode != "P":
-        raise ValueError("Unsupported BLP image mode")
-
-    magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
-    fp.write(magic)
-
-    fp.write(struct.pack("<i", 1))  # Uncompressed or DirectX compression
-    fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
-    fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
-    fp.write(struct.pack("<b", 0))  # alpha encoding
-    fp.write(struct.pack("<b", 0))  # mips
-    fp.write(struct.pack("<II", *im.size))
-    if magic == b"BLP1":
-        fp.write(struct.pack("<i", 5))
-        fp.write(struct.pack("<i", 0))
-
-    ImageFile._save(im, fp, [("BLP", (0, 0) + im.size, 0, im.mode)])
-
-
-Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
-Image.register_extension(BlpImageFile.format, ".blp")
-Image.register_decoder("BLP1", BLP1Decoder)
-Image.register_decoder("BLP2", BLP2Decoder)
-
-Image.register_save(BlpImageFile.format, _save)
-Image.register_encoder("BLP", BLPEncoder)

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/BmpImagePlugin.py

@@ -1,464 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# BMP file handler
-#
-# Windows (and OS/2) native bitmap storage format.
-#
-# history:
-# 1995-09-01 fl   Created
-# 1996-04-30 fl   Added save
-# 1997-08-27 fl   Fixed save of 1-bit images
-# 1998-03-06 fl   Load P images as L where possible
-# 1998-07-03 fl   Load P images as 1 where possible
-# 1998-12-29 fl   Handle small palettes
-# 2002-12-30 fl   Fixed load of 1-bit palette images
-# 2003-04-21 fl   Fixed load of 1-bit monochrome images
-# 2003-04-23 fl   Added limited support for BI_BITFIELDS compression
-#
-# Copyright (c) 1997-2003 by Secret Labs AB
-# Copyright (c) 1995-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-import os
-
-from . import Image, ImageFile, ImagePalette
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-from ._binary import o8
-from ._binary import o16le as o16
-from ._binary import o32le as o32
-
-#
-# --------------------------------------------------------------------
-# Read BMP file
-
-BIT2MODE = {
-    # bits => mode, rawmode
-    1: ("P", "P;1"),
-    4: ("P", "P;4"),
-    8: ("P", "P"),
-    16: ("RGB", "BGR;15"),
-    24: ("RGB", "BGR"),
-    32: ("RGB", "BGRX"),
-}
-
-
-def _accept(prefix):
-    return prefix[:2] == b"BM"
-
-
-def _dib_accept(prefix):
-    return i32(prefix) in [12, 40, 64, 108, 124]
-
-
-# =============================================================================
-# Image plugin for the Windows BMP format.
-# =============================================================================
-class BmpImageFile(ImageFile.ImageFile):
-    """Image plugin for the Windows Bitmap format (BMP)"""
-
-    # ------------------------------------------------------------- Description
-    format_description = "Windows Bitmap"
-    format = "BMP"
-
-    # -------------------------------------------------- BMP Compression values
-    COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
-    for k, v in COMPRESSIONS.items():
-        vars()[k] = v
-
-    def _bitmap(self, header=0, offset=0):
-        """Read relevant info about the BMP"""
-        read, seek = self.fp.read, self.fp.seek
-        if header:
-            seek(header)
-        # read bmp header size @offset 14 (this is part of the header size)
-        file_info = {"header_size": i32(read(4)), "direction": -1}
-
-        # -------------------- If requested, read header at a specific position
-        # read the rest of the bmp header, without its size
-        header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
-
-        # -------------------------------------------------- IBM OS/2 Bitmap v1
-        # ----- This format has different offsets because of width/height types
-        if file_info["header_size"] == 12:
-            file_info["width"] = i16(header_data, 0)
-            file_info["height"] = i16(header_data, 2)
-            file_info["planes"] = i16(header_data, 4)
-            file_info["bits"] = i16(header_data, 6)
-            file_info["compression"] = self.RAW
-            file_info["palette_padding"] = 3
-
-        # --------------------------------------------- Windows Bitmap v2 to v5
-        # v3, OS/2 v2, v4, v5
-        elif file_info["header_size"] in (40, 64, 108, 124):
-            file_info["y_flip"] = header_data[7] == 0xFF
-            file_info["direction"] = 1 if file_info["y_flip"] else -1
-            file_info["width"] = i32(header_data, 0)
-            file_info["height"] = (
-                i32(header_data, 4)
-                if not file_info["y_flip"]
-                else 2**32 - i32(header_data, 4)
-            )
-            file_info["planes"] = i16(header_data, 8)
-            file_info["bits"] = i16(header_data, 10)
-            file_info["compression"] = i32(header_data, 12)
-            # byte size of pixel data
-            file_info["data_size"] = i32(header_data, 16)
-            file_info["pixels_per_meter"] = (
-                i32(header_data, 20),
-                i32(header_data, 24),
-            )
-            file_info["colors"] = i32(header_data, 28)
-            file_info["palette_padding"] = 4
-            self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
-            if file_info["compression"] == self.BITFIELDS:
-                if len(header_data) >= 52:
-                    for idx, mask in enumerate(
-                        ["r_mask", "g_mask", "b_mask", "a_mask"]
-                    ):
-                        file_info[mask] = i32(header_data, 36 + idx * 4)
-                else:
-                    # 40 byte headers only have the three components in the
-                    # bitfields masks, ref:
-                    # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
-                    # See also
-                    # https://github.com/python-pillow/Pillow/issues/1293
-                    # There is a 4th component in the RGBQuad, in the alpha
-                    # location, but it is listed as a reserved component,
-                    # and it is not generally an alpha channel
-                    file_info["a_mask"] = 0x0
-                    for mask in ["r_mask", "g_mask", "b_mask"]:
-                        file_info[mask] = i32(read(4))
-                file_info["rgb_mask"] = (
-                    file_info["r_mask"],
-                    file_info["g_mask"],
-                    file_info["b_mask"],
-                )
-                file_info["rgba_mask"] = (
-                    file_info["r_mask"],
-                    file_info["g_mask"],
-                    file_info["b_mask"],
-                    file_info["a_mask"],
-                )
-        else:
-            raise OSError(f"Unsupported BMP header type ({file_info['header_size']})")
-
-        # ------------------ Special case : header is reported 40, which
-        # ---------------------- is shorter than real size for bpp >= 16
-        self._size = file_info["width"], file_info["height"]
-
-        # ------- If color count was not found in the header, compute from bits
-        file_info["colors"] = (
-            file_info["colors"]
-            if file_info.get("colors", 0)
-            else (1 << file_info["bits"])
-        )
-        if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
-            offset += 4 * file_info["colors"]
-
-        # ---------------------- Check bit depth for unusual unsupported values
-        self.mode, raw_mode = BIT2MODE.get(file_info["bits"], (None, None))
-        if self.mode is None:
-            raise OSError(f"Unsupported BMP pixel depth ({file_info['bits']})")
-
-        # ---------------- Process BMP with Bitfields compression (not palette)
-        decoder_name = "raw"
-        if file_info["compression"] == self.BITFIELDS:
-            SUPPORTED = {
-                32: [
-                    (0xFF0000, 0xFF00, 0xFF, 0x0),
-                    (0xFF000000, 0xFF0000, 0xFF00, 0x0),
-                    (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
-                    (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
-                    (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
-                    (0x0, 0x0, 0x0, 0x0),
-                ],
-                24: [(0xFF0000, 0xFF00, 0xFF)],
-                16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
-            }
-            MASK_MODES = {
-                (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
-                (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
-                (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
-                (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
-                (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
-                (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
-                (24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
-                (16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
-                (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
-            }
-            if file_info["bits"] in SUPPORTED:
-                if (
-                    file_info["bits"] == 32
-                    and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
-                ):
-                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
-                    self.mode = "RGBA" if "A" in raw_mode else self.mode
-                elif (
-                    file_info["bits"] in (24, 16)
-                    and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
-                ):
-                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
-                else:
-                    raise OSError("Unsupported BMP bitfields layout")
-            else:
-                raise OSError("Unsupported BMP bitfields layout")
-        elif file_info["compression"] == self.RAW:
-            if file_info["bits"] == 32 and header == 22:  # 32-bit .cur offset
-                raw_mode, self.mode = "BGRA", "RGBA"
-        elif file_info["compression"] in (self.RLE8, self.RLE4):
-            decoder_name = "bmp_rle"
-        else:
-            raise OSError(f"Unsupported BMP compression ({file_info['compression']})")
-
-        # --------------- Once the header is processed, process the palette/LUT
-        if self.mode == "P":  # Paletted for 1, 4 and 8 bit images
-
-            # ---------------------------------------------------- 1-bit images
-            if not (0 < file_info["colors"] <= 65536):
-                raise OSError(f"Unsupported BMP Palette size ({file_info['colors']})")
-            else:
-                padding = file_info["palette_padding"]
-                palette = read(padding * file_info["colors"])
-                greyscale = True
-                indices = (
-                    (0, 255)
-                    if file_info["colors"] == 2
-                    else list(range(file_info["colors"]))
-                )
-
-                # ----------------- Check if greyscale and ignore palette if so
-                for ind, val in enumerate(indices):
-                    rgb = palette[ind * padding : ind * padding + 3]
-                    if rgb != o8(val) * 3:
-                        greyscale = False
-
-                # ------- If all colors are grey, white or black, ditch palette
-                if greyscale:
-                    self.mode = "1" if file_info["colors"] == 2 else "L"
-                    raw_mode = self.mode
-                else:
-                    self.mode = "P"
-                    self.palette = ImagePalette.raw(
-                        "BGRX" if padding == 4 else "BGR", palette
-                    )
-
-        # ---------------------------- Finally set the tile data for the plugin
-        self.info["compression"] = file_info["compression"]
-        args = [raw_mode]
-        if decoder_name == "bmp_rle":
-            args.append(file_info["compression"] == self.RLE4)
-        else:
-            args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
-        args.append(file_info["direction"])
-        self.tile = [
-            (
-                decoder_name,
-                (0, 0, file_info["width"], file_info["height"]),
-                offset or self.fp.tell(),
-                tuple(args),
-            )
-        ]
-
-    def _open(self):
-        """Open file, check magic number and read header"""
-        # read 14 bytes: magic number, filesize, reserved, header final offset
-        head_data = self.fp.read(14)
-        # choke if the file does not have the required magic bytes
-        if not _accept(head_data):
-            raise SyntaxError("Not a BMP file")
-        # read the start position of the BMP image data (u32)
-        offset = i32(head_data, 10)
-        # load bitmap information (offset=raster info)
-        self._bitmap(offset=offset)
-
-
-class BmpRleDecoder(ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer):
-        rle4 = self.args[1]
-        data = bytearray()
-        x = 0
-        while len(data) < self.state.xsize * self.state.ysize:
-            pixels = self.fd.read(1)
-            byte = self.fd.read(1)
-            if not pixels or not byte:
-                break
-            num_pixels = pixels[0]
-            if num_pixels:
-                # encoded mode
-                if x + num_pixels > self.state.xsize:
-                    # Too much data for row
-                    num_pixels = max(0, self.state.xsize - x)
-                if rle4:
-                    first_pixel = o8(byte[0] >> 4)
-                    second_pixel = o8(byte[0] & 0x0F)
-                    for index in range(num_pixels):
-                        if index % 2 == 0:
-                            data += first_pixel
-                        else:
-                            data += second_pixel
-                else:
-                    data += byte * num_pixels
-                x += num_pixels
-            else:
-                if byte[0] == 0:
-                    # end of line
-                    while len(data) % self.state.xsize != 0:
-                        data += b"\x00"
-                    x = 0
-                elif byte[0] == 1:
-                    # end of bitmap
-                    break
-                elif byte[0] == 2:
-                    # delta
-                    bytes_read = self.fd.read(2)
-                    if len(bytes_read) < 2:
-                        break
-                    right, up = self.fd.read(2)
-                    data += b"\x00" * (right + up * self.state.xsize)
-                    x = len(data) % self.state.xsize
-                else:
-                    # absolute mode
-                    if rle4:
-                        # 2 pixels per byte
-                        byte_count = byte[0] // 2
-                        bytes_read = self.fd.read(byte_count)
-                        for byte_read in bytes_read:
-                            data += o8(byte_read >> 4)
-                            data += o8(byte_read & 0x0F)
-                    else:
-                        byte_count = byte[0]
-                        bytes_read = self.fd.read(byte_count)
-                        data += bytes_read
-                    if len(bytes_read) < byte_count:
-                        break
-                    x += byte[0]
-
-                    # align to 16-bit word boundary
-                    if self.fd.tell() % 2 != 0:
-                        self.fd.seek(1, os.SEEK_CUR)
-        rawmode = "L" if self.mode == "L" else "P"
-        self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
-        return -1, 0
-
-
-# =============================================================================
-# Image plugin for the DIB format (BMP alias)
-# =============================================================================
-class DibImageFile(BmpImageFile):
-
-    format = "DIB"
-    format_description = "Windows Bitmap"
-
-    def _open(self):
-        self._bitmap()
-
-
-#
-# --------------------------------------------------------------------
-# Write BMP file
-
-
-SAVE = {
-    "1": ("1", 1, 2),
-    "L": ("L", 8, 256),
-    "P": ("P", 8, 256),
-    "RGB": ("BGR", 24, 0),
-    "RGBA": ("BGRA", 32, 0),
-}
-
-
-def _dib_save(im, fp, filename):
-    _save(im, fp, filename, False)
-
-
-def _save(im, fp, filename, bitmap_header=True):
-    try:
-        rawmode, bits, colors = SAVE[im.mode]
-    except KeyError as e:
-        raise OSError(f"cannot write mode {im.mode} as BMP") from e
-
-    info = im.encoderinfo
-
-    dpi = info.get("dpi", (96, 96))
-
-    # 1 meter == 39.3701 inches
-    ppm = tuple(map(lambda x: int(x * 39.3701 + 0.5), dpi))
-
-    stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
-    header = 40  # or 64 for OS/2 version 2
-    image = stride * im.size[1]
-
-    if im.mode == "1":
-        palette = b"".join(o8(i) * 4 for i in (0, 255))
-    elif im.mode == "L":
-        palette = b"".join(o8(i) * 4 for i in range(256))
-    elif im.mode == "P":
-        palette = im.im.getpalette("RGB", "BGRX")
-        colors = len(palette) // 4
-    else:
-        palette = None
-
-    # bitmap header
-    if bitmap_header:
-        offset = 14 + header + colors * 4
-        file_size = offset + image
-        if file_size > 2**32 - 1:
-            raise ValueError("File size is too large for the BMP format")
-        fp.write(
-            b"BM"  # file type (magic)
-            + o32(file_size)  # file size
-            + o32(0)  # reserved
-            + o32(offset)  # image data offset
-        )
-
-    # bitmap info header
-    fp.write(
-        o32(header)  # info header size
-        + o32(im.size[0])  # width
-        + o32(im.size[1])  # height
-        + o16(1)  # planes
-        + o16(bits)  # depth
-        + o32(0)  # compression (0=uncompressed)
-        + o32(image)  # size of bitmap
-        + o32(ppm[0])  # resolution
-        + o32(ppm[1])  # resolution
-        + o32(colors)  # colors used
-        + o32(colors)  # colors important
-    )
-
-    fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
-
-    if palette:
-        fp.write(palette)
-
-    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
-
-
-#
-# --------------------------------------------------------------------
-# Registry
-
-
-Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
-Image.register_save(BmpImageFile.format, _save)
-
-Image.register_extension(BmpImageFile.format, ".bmp")
-
-Image.register_mime(BmpImageFile.format, "image/bmp")
-
-Image.register_decoder("bmp_rle", BmpRleDecoder)
-
-Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
-Image.register_save(DibImageFile.format, _dib_save)
-
-Image.register_extension(DibImageFile.format, ".dib")
-
-Image.register_mime(DibImageFile.format, "image/bmp")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/BufrStubImagePlugin.py

@@ -1,73 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# BUFR stub adapter
-#
-# Copyright (c) 1996-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler):
-    """
-    Install application-specific BUFR image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix):
-    return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
-
-
-class BufrStubImageFile(ImageFile.StubImageFile):
-
-    format = "BUFR"
-    format_description = "BUFR"
-
-    def _open(self):
-
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(4)):
-            raise SyntaxError("Not a BUFR file")
-
-        self.fp.seek(offset)
-
-        # make something up
-        self.mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self):
-        return _handler
-
-
-def _save(im, fp, filename):
-    if _handler is None or not hasattr(_handler, "save"):
-        raise OSError("BUFR save handler not installed")
-    _handler.save(im, fp, filename)
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
-Image.register_save(BufrStubImageFile.format, _save)
-
-Image.register_extension(BufrStubImageFile.format, ".bufr")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ContainerIO.py

@@ -1,120 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a class to read from a container file
-#
-# History:
-# 1995-06-18 fl     Created
-# 1995-09-07 fl     Added readline(), readlines()
-#
-# Copyright (c) 1997-2001 by Secret Labs AB
-# Copyright (c) 1995 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-import io
-
-
-class ContainerIO:
-    """
-    A file object that provides read access to a part of an existing
-    file (for example a TAR file).
-    """
-
-    def __init__(self, file, offset, length):
-        """
-        Create file object.
-
-        :param file: Existing file.
-        :param offset: Start of region, in bytes.
-        :param length: Size of region, in bytes.
-        """
-        self.fh = file
-        self.pos = 0
-        self.offset = offset
-        self.length = length
-        self.fh.seek(offset)
-
-    ##
-    # Always false.
-
-    def isatty(self):
-        return False
-
-    def seek(self, offset, mode=io.SEEK_SET):
-        """
-        Move file pointer.
-
-        :param offset: Offset in bytes.
-        :param mode: Starting position. Use 0 for beginning of region, 1
-           for current offset, and 2 for end of region.  You cannot move
-           the pointer outside the defined region.
-        """
-        if mode == 1:
-            self.pos = self.pos + offset
-        elif mode == 2:
-            self.pos = self.length + offset
-        else:
-            self.pos = offset
-        # clamp
-        self.pos = max(0, min(self.pos, self.length))
-        self.fh.seek(self.offset + self.pos)
-
-    def tell(self):
-        """
-        Get current file pointer.
-
-        :returns: Offset from start of region, in bytes.
-        """
-        return self.pos
-
-    def read(self, n=0):
-        """
-        Read data.
-
-        :param n: Number of bytes to read. If omitted or zero,
-            read until end of region.
-        :returns: An 8-bit string.
-        """
-        if n:
-            n = min(n, self.length - self.pos)
-        else:
-            n = self.length - self.pos
-        if not n:  # EOF
-            return b"" if "b" in self.fh.mode else ""
-        self.pos = self.pos + n
-        return self.fh.read(n)
-
-    def readline(self):
-        """
-        Read a line of text.
-
-        :returns: An 8-bit string.
-        """
-        s = b"" if "b" in self.fh.mode else ""
-        newline_character = b"\n" if "b" in self.fh.mode else "\n"
-        while True:
-            c = self.read(1)
-            if not c:
-                break
-            s = s + c
-            if c == newline_character:
-                break
-        return s
-
-    def readlines(self):
-        """
-        Read multiple lines of text.
-
-        :returns: A list of 8-bit strings.
-        """
-        lines = []
-        while True:
-            s = self.readline()
-            if not s:
-                break
-            lines.append(s)
-        return lines

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/CurImagePlugin.py

@@ -1,75 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# Windows Cursor support for PIL
-#
-# notes:
-#       uses BmpImagePlugin.py to read the bitmap data.
-#
-# history:
-#       96-05-27 fl     Created
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-from . import BmpImagePlugin, Image
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-
-#
-# --------------------------------------------------------------------
-
-
-def _accept(prefix):
-    return prefix[:4] == b"\0\0\2\0"
-
-
-##
-# Image plugin for Windows Cursor files.
-
-
-class CurImageFile(BmpImagePlugin.BmpImageFile):
-
-    format = "CUR"
-    format_description = "Windows Cursor"
-
-    def _open(self):
-
-        offset = self.fp.tell()
-
-        # check magic
-        s = self.fp.read(6)
-        if not _accept(s):
-            raise SyntaxError("not a CUR file")
-
-        # pick the largest cursor in the file
-        m = b""
-        for i in range(i16(s, 4)):
-            s = self.fp.read(16)
-            if not m:
-                m = s
-            elif s[0] > m[0] and s[1] > m[1]:
-                m = s
-        if not m:
-            raise TypeError("No cursors were found")
-
-        # load as bitmap
-        self._bitmap(i32(m, 12) + offset)
-
-        # patch up the bitmap height
-        self._size = self.size[0], self.size[1] // 2
-        d, e, o, a = self.tile[0]
-        self.tile[0] = d, (0, 0) + self.size, o, a
-
-        return
-
-
-#
-# --------------------------------------------------------------------
-
-Image.register_open(CurImageFile.format, CurImageFile, _accept)
-
-Image.register_extension(CurImageFile.format, ".cur")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/DcxImagePlugin.py

@@ -1,80 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# DCX file handling
-#
-# DCX is a container file format defined by Intel, commonly used
-# for fax applications.  Each DCX file consists of a directory
-# (a list of file offsets) followed by a set of (usually 1-bit)
-# PCX files.
-#
-# History:
-# 1995-09-09 fl   Created
-# 1996-03-20 fl   Properly derived from PcxImageFile.
-# 1998-07-15 fl   Renamed offset attribute to avoid name clash
-# 2002-07-30 fl   Fixed file handling
-#
-# Copyright (c) 1997-98 by Secret Labs AB.
-# Copyright (c) 1995-96 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image
-from ._binary import i32le as i32
-from .PcxImagePlugin import PcxImageFile
-
-MAGIC = 0x3ADE68B1  # QUIZ: what's this value, then?
-
-
-def _accept(prefix):
-    return len(prefix) >= 4 and i32(prefix) == MAGIC
-
-
-##
-# Image plugin for the Intel DCX format.
-
-
-class DcxImageFile(PcxImageFile):
-
-    format = "DCX"
-    format_description = "Intel DCX"
-    _close_exclusive_fp_after_loading = False
-
-    def _open(self):
-
-        # Header
-        s = self.fp.read(4)
-        if not _accept(s):
-            raise SyntaxError("not a DCX file")
-
-        # Component directory
-        self._offset = []
-        for i in range(1024):
-            offset = i32(self.fp.read(4))
-            if not offset:
-                break
-            self._offset.append(offset)
-
-        self._fp = self.fp
-        self.frame = None
-        self.n_frames = len(self._offset)
-        self.is_animated = self.n_frames > 1
-        self.seek(0)
-
-    def seek(self, frame):
-        if not self._seek_check(frame):
-            return
-        self.frame = frame
-        self.fp = self._fp
-        self.fp.seek(self._offset[frame])
-        PcxImageFile._open(self)
-
-    def tell(self):
-        return self.frame
-
-
-Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
-
-Image.register_extension(DcxImageFile.format, ".dcx")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/DdsImagePlugin.py

@@ -1,267 +0,0 @@
-"""
-A Pillow loader for .dds files (S3TC-compressed aka DXTC)
-Jerome Leclanche <jerome@leclan.ch>
-
-Documentation:
-  https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
-
-The contents of this file are hereby released in the public domain (CC0)
-Full text of the CC0 license:
-  https://creativecommons.org/publicdomain/zero/1.0/
-"""
-
-import struct
-from io import BytesIO
-
-from . import Image, ImageFile
-from ._binary import o32le as o32
-
-# Magic ("DDS ")
-DDS_MAGIC = 0x20534444
-
-# DDS flags
-DDSD_CAPS = 0x1
-DDSD_HEIGHT = 0x2
-DDSD_WIDTH = 0x4
-DDSD_PITCH = 0x8
-DDSD_PIXELFORMAT = 0x1000
-DDSD_MIPMAPCOUNT = 0x20000
-DDSD_LINEARSIZE = 0x80000
-DDSD_DEPTH = 0x800000
-
-# DDS caps
-DDSCAPS_COMPLEX = 0x8
-DDSCAPS_TEXTURE = 0x1000
-DDSCAPS_MIPMAP = 0x400000
-
-DDSCAPS2_CUBEMAP = 0x200
-DDSCAPS2_CUBEMAP_POSITIVEX = 0x400
-DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800
-DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000
-DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000
-DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000
-DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000
-DDSCAPS2_VOLUME = 0x200000
-
-# Pixel Format
-DDPF_ALPHAPIXELS = 0x1
-DDPF_ALPHA = 0x2
-DDPF_FOURCC = 0x4
-DDPF_PALETTEINDEXED8 = 0x20
-DDPF_RGB = 0x40
-DDPF_LUMINANCE = 0x20000
-
-
-# dds.h
-
-DDS_FOURCC = DDPF_FOURCC
-DDS_RGB = DDPF_RGB
-DDS_RGBA = DDPF_RGB | DDPF_ALPHAPIXELS
-DDS_LUMINANCE = DDPF_LUMINANCE
-DDS_LUMINANCEA = DDPF_LUMINANCE | DDPF_ALPHAPIXELS
-DDS_ALPHA = DDPF_ALPHA
-DDS_PAL8 = DDPF_PALETTEINDEXED8
-
-DDS_HEADER_FLAGS_TEXTURE = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
-DDS_HEADER_FLAGS_MIPMAP = DDSD_MIPMAPCOUNT
-DDS_HEADER_FLAGS_VOLUME = DDSD_DEPTH
-DDS_HEADER_FLAGS_PITCH = DDSD_PITCH
-DDS_HEADER_FLAGS_LINEARSIZE = DDSD_LINEARSIZE
-
-DDS_HEIGHT = DDSD_HEIGHT
-DDS_WIDTH = DDSD_WIDTH
-
-DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS_TEXTURE
-DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
-DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS_COMPLEX
-
-DDS_CUBEMAP_POSITIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
-DDS_CUBEMAP_NEGATIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
-DDS_CUBEMAP_POSITIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
-DDS_CUBEMAP_NEGATIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
-DDS_CUBEMAP_POSITIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
-DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ
-
-
-# DXT1
-DXT1_FOURCC = 0x31545844
-
-# DXT3
-DXT3_FOURCC = 0x33545844
-
-# DXT5
-DXT5_FOURCC = 0x35545844
-
-
-# dxgiformat.h
-
-DXGI_FORMAT_R8G8B8A8_TYPELESS = 27
-DXGI_FORMAT_R8G8B8A8_UNORM = 28
-DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29
-DXGI_FORMAT_BC5_TYPELESS = 82
-DXGI_FORMAT_BC5_UNORM = 83
-DXGI_FORMAT_BC5_SNORM = 84
-DXGI_FORMAT_BC6H_UF16 = 95
-DXGI_FORMAT_BC6H_SF16 = 96
-DXGI_FORMAT_BC7_TYPELESS = 97
-DXGI_FORMAT_BC7_UNORM = 98
-DXGI_FORMAT_BC7_UNORM_SRGB = 99
-
-
-class DdsImageFile(ImageFile.ImageFile):
-    format = "DDS"
-    format_description = "DirectDraw Surface"
-
-    def _open(self):
-        if not _accept(self.fp.read(4)):
-            raise SyntaxError("not a DDS file")
-        (header_size,) = struct.unpack("<I", self.fp.read(4))
-        if header_size != 124:
-            raise OSError(f"Unsupported header size {repr(header_size)}")
-        header_bytes = self.fp.read(header_size - 4)
-        if len(header_bytes) != 120:
-            raise OSError(f"Incomplete header: {len(header_bytes)} bytes")
-        header = BytesIO(header_bytes)
-
-        flags, height, width = struct.unpack("<3I", header.read(12))
-        self._size = (width, height)
-        self.mode = "RGBA"
-
-        pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))
-        struct.unpack("<11I", header.read(44))  # reserved
-
-        # pixel format
-        pfsize, pfflags = struct.unpack("<2I", header.read(8))
-        fourcc = header.read(4)
-        (bitcount,) = struct.unpack("<I", header.read(4))
-        masks = struct.unpack("<4I", header.read(16))
-        if pfflags & DDPF_RGB:
-            # Texture contains uncompressed RGB data
-            masks = {mask: ["R", "G", "B", "A"][i] for i, mask in enumerate(masks)}
-            rawmode = ""
-            if bitcount == 32:
-                rawmode += masks[0xFF000000]
-            else:
-                self.mode = "RGB"
-            rawmode += masks[0xFF0000] + masks[0xFF00] + masks[0xFF]
-
-            self.tile = [("raw", (0, 0) + self.size, 0, (rawmode[::-1], 0, 1))]
-        else:
-            data_start = header_size + 4
-            n = 0
-            if fourcc == b"DXT1":
-                self.pixel_format = "DXT1"
-                n = 1
-            elif fourcc == b"DXT3":
-                self.pixel_format = "DXT3"
-                n = 2
-            elif fourcc == b"DXT5":
-                self.pixel_format = "DXT5"
-                n = 3
-            elif fourcc == b"ATI1":
-                self.pixel_format = "BC4"
-                n = 4
-                self.mode = "L"
-            elif fourcc == b"ATI2":
-                self.pixel_format = "BC5"
-                n = 5
-                self.mode = "RGB"
-            elif fourcc == b"BC5S":
-                self.pixel_format = "BC5S"
-                n = 5
-                self.mode = "RGB"
-            elif fourcc == b"DX10":
-                data_start += 20
-                # ignoring flags which pertain to volume textures and cubemaps
-                (dxgi_format,) = struct.unpack("<I", self.fp.read(4))
-                self.fp.read(16)
-                if dxgi_format in (DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM):
-                    self.pixel_format = "BC5"
-                    n = 5
-                    self.mode = "RGB"
-                elif dxgi_format == DXGI_FORMAT_BC5_SNORM:
-                    self.pixel_format = "BC5S"
-                    n = 5
-                    self.mode = "RGB"
-                elif dxgi_format == DXGI_FORMAT_BC6H_UF16:
-                    self.pixel_format = "BC6H"
-                    n = 6
-                    self.mode = "RGB"
-                elif dxgi_format == DXGI_FORMAT_BC6H_SF16:
-                    self.pixel_format = "BC6HS"
-                    n = 6
-                    self.mode = "RGB"
-                elif dxgi_format in (DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM):
-                    self.pixel_format = "BC7"
-                    n = 7
-                elif dxgi_format == DXGI_FORMAT_BC7_UNORM_SRGB:
-                    self.pixel_format = "BC7"
-                    self.info["gamma"] = 1 / 2.2
-                    n = 7
-                elif dxgi_format in (
-                    DXGI_FORMAT_R8G8B8A8_TYPELESS,
-                    DXGI_FORMAT_R8G8B8A8_UNORM,
-                    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
-                ):
-                    self.tile = [("raw", (0, 0) + self.size, 0, ("RGBA", 0, 1))]
-                    if dxgi_format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-                        self.info["gamma"] = 1 / 2.2
-                    return
-                else:
-                    raise NotImplementedError(
-                        f"Unimplemented DXGI format {dxgi_format}"
-                    )
-            else:
-                raise NotImplementedError(f"Unimplemented pixel format {repr(fourcc)}")
-
-            self.tile = [
-                ("bcn", (0, 0) + self.size, data_start, (n, self.pixel_format))
-            ]
-
-    def load_seek(self, pos):
-        pass
-
-
-def _save(im, fp, filename):
-    if im.mode not in ("RGB", "RGBA"):
-        raise OSError(f"cannot write mode {im.mode} as DDS")
-
-    fp.write(
-        o32(DDS_MAGIC)
-        + o32(124)  # header size
-        + o32(
-            DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT
-        )  # flags
-        + o32(im.height)
-        + o32(im.width)
-        + o32((im.width * (32 if im.mode == "RGBA" else 24) + 7) // 8)  # pitch
-        + o32(0)  # depth
-        + o32(0)  # mipmaps
-        + o32(0) * 11  # reserved
-        + o32(32)  # pfsize
-        + o32(DDS_RGBA if im.mode == "RGBA" else DDPF_RGB)  # pfflags
-        + o32(0)  # fourcc
-        + o32(32 if im.mode == "RGBA" else 24)  # bitcount
-        + o32(0xFF0000)  # rbitmask
-        + o32(0xFF00)  # gbitmask
-        + o32(0xFF)  # bbitmask
-        + o32(0xFF000000 if im.mode == "RGBA" else 0)  # abitmask
-        + o32(DDSCAPS_TEXTURE)  # dwCaps
-        + o32(0)  # dwCaps2
-        + o32(0)  # dwCaps3
-        + o32(0)  # dwCaps4
-        + o32(0)  # dwReserved2
-    )
-    if im.mode == "RGBA":
-        r, g, b, a = im.split()
-        im = Image.merge("RGBA", (a, r, g, b))
-    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (im.mode[::-1], 0, 1))])
-
-
-def _accept(prefix):
-    return prefix[:4] == b"DDS "
-
-
-Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
-Image.register_save(DdsImageFile.format, _save)
-Image.register_extension(DdsImageFile.format, ".dds")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/EpsImagePlugin.py

@@ -1,414 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# EPS file handling
-#
-# History:
-# 1995-09-01 fl   Created (0.1)
-# 1996-05-18 fl   Don't choke on "atend" fields, Ghostscript interface (0.2)
-# 1996-08-22 fl   Don't choke on floating point BoundingBox values
-# 1996-08-23 fl   Handle files from Macintosh (0.3)
-# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
-# 2003-09-07 fl   Check gs.close status (from Federico Di Gregorio) (0.5)
-# 2014-05-07 e    Handling of EPS with binary preview and fixed resolution
-#                 resizing
-#
-# Copyright (c) 1997-2003 by Secret Labs AB.
-# Copyright (c) 1995-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import io
-import os
-import re
-import subprocess
-import sys
-import tempfile
-
-from . import Image, ImageFile
-from ._binary import i32le as i32
-
-#
-# --------------------------------------------------------------------
-
-split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
-field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
-
-gs_windows_binary = None
-if sys.platform.startswith("win"):
-    import shutil
-
-    for binary in ("gswin32c", "gswin64c", "gs"):
-        if shutil.which(binary) is not None:
-            gs_windows_binary = binary
-            break
-    else:
-        gs_windows_binary = False
-
-
-def has_ghostscript():
-    if gs_windows_binary:
-        return True
-    if not sys.platform.startswith("win"):
-        try:
-            subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
-            return True
-        except OSError:
-            # No Ghostscript
-            pass
-    return False
-
-
-def Ghostscript(tile, size, fp, scale=1, transparency=False):
-    """Render an image using Ghostscript"""
-
-    # Unpack decoder tile
-    decoder, tile, offset, data = tile[0]
-    length, bbox = data
-
-    # Hack to support hi-res rendering
-    scale = int(scale) or 1
-    # orig_size = size
-    # orig_bbox = bbox
-    size = (size[0] * scale, size[1] * scale)
-    # resolution is dependent on bbox and size
-    res = (
-        72.0 * size[0] / (bbox[2] - bbox[0]),
-        72.0 * size[1] / (bbox[3] - bbox[1]),
-    )
-
-    out_fd, outfile = tempfile.mkstemp()
-    os.close(out_fd)
-
-    infile_temp = None
-    if hasattr(fp, "name") and os.path.exists(fp.name):
-        infile = fp.name
-    else:
-        in_fd, infile_temp = tempfile.mkstemp()
-        os.close(in_fd)
-        infile = infile_temp
-
-        # Ignore length and offset!
-        # Ghostscript can read it
-        # Copy whole file to read in Ghostscript
-        with open(infile_temp, "wb") as f:
-            # fetch length of fp
-            fp.seek(0, io.SEEK_END)
-            fsize = fp.tell()
-            # ensure start position
-            # go back
-            fp.seek(0)
-            lengthfile = fsize
-            while lengthfile > 0:
-                s = fp.read(min(lengthfile, 100 * 1024))
-                if not s:
-                    break
-                lengthfile -= len(s)
-                f.write(s)
-
-    device = "pngalpha" if transparency else "ppmraw"
-
-    # Build Ghostscript command
-    command = [
-        "gs",
-        "-q",  # quiet mode
-        "-g%dx%d" % size,  # set output geometry (pixels)
-        "-r%fx%f" % res,  # set input DPI (dots per inch)
-        "-dBATCH",  # exit after processing
-        "-dNOPAUSE",  # don't pause between pages
-        "-dSAFER",  # safe mode
-        f"-sDEVICE={device}",
-        f"-sOutputFile={outfile}",  # output file
-        # adjust for image origin
-        "-c",
-        f"{-bbox[0]} {-bbox[1]} translate",
-        "-f",
-        infile,  # input file
-        # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
-        "-c",
-        "showpage",
-    ]
-
-    if gs_windows_binary is not None:
-        if not gs_windows_binary:
-            raise OSError("Unable to locate Ghostscript on paths")
-        command[0] = gs_windows_binary
-
-    # push data through Ghostscript
-    try:
-        startupinfo = None
-        if sys.platform.startswith("win"):
-            startupinfo = subprocess.STARTUPINFO()
-            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-        subprocess.check_call(command, startupinfo=startupinfo)
-        out_im = Image.open(outfile)
-        out_im.load()
-    finally:
-        try:
-            os.unlink(outfile)
-            if infile_temp:
-                os.unlink(infile_temp)
-        except OSError:
-            pass
-
-    im = out_im.im.copy()
-    out_im.close()
-    return im
-
-
-class PSFile:
-    """
-    Wrapper for bytesio object that treats either CR or LF as end of line.
-    """
-
-    def __init__(self, fp):
-        self.fp = fp
-        self.char = None
-
-    def seek(self, offset, whence=io.SEEK_SET):
-        self.char = None
-        self.fp.seek(offset, whence)
-
-    def readline(self):
-        s = [self.char or b""]
-        self.char = None
-
-        c = self.fp.read(1)
-        while (c not in b"\r\n") and len(c):
-            s.append(c)
-            c = self.fp.read(1)
-
-        self.char = self.fp.read(1)
-        # line endings can be 1 or 2 of \r \n, in either order
-        if self.char in b"\r\n":
-            self.char = None
-
-        return b"".join(s).decode("latin-1")
-
-
-def _accept(prefix):
-    return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
-
-
-##
-# Image plugin for Encapsulated PostScript.  This plugin supports only
-# a few variants of this format.
-
-
-class EpsImageFile(ImageFile.ImageFile):
-    """EPS File Parser for the Python Imaging Library"""
-
-    format = "EPS"
-    format_description = "Encapsulated Postscript"
-
-    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
-
-    def _open(self):
-        (length, offset) = self._find_offset(self.fp)
-
-        # Rewrap the open file pointer in something that will
-        # convert line endings and decode to latin-1.
-        fp = PSFile(self.fp)
-
-        # go to offset - start of "%!PS"
-        fp.seek(offset)
-
-        box = None
-
-        self.mode = "RGB"
-        self._size = 1, 1  # FIXME: huh?
-
-        #
-        # Load EPS header
-
-        s_raw = fp.readline()
-        s = s_raw.strip("\r\n")
-
-        while s_raw:
-            if s:
-                if len(s) > 255:
-                    raise SyntaxError("not an EPS file")
-
-                try:
-                    m = split.match(s)
-                except re.error as e:
-                    raise SyntaxError("not an EPS file") from e
-
-                if m:
-                    k, v = m.group(1, 2)
-                    self.info[k] = v
-                    if k == "BoundingBox":
-                        try:
-                            # Note: The DSC spec says that BoundingBox
-                            # fields should be integers, but some drivers
-                            # put floating point values there anyway.
-                            box = [int(float(i)) for i in v.split()]
-                            self._size = box[2] - box[0], box[3] - box[1]
-                            self.tile = [
-                                ("eps", (0, 0) + self.size, offset, (length, box))
-                            ]
-                        except Exception:
-                            pass
-
-                else:
-                    m = field.match(s)
-                    if m:
-                        k = m.group(1)
-
-                        if k == "EndComments":
-                            break
-                        if k[:8] == "PS-Adobe":
-                            self.info[k[:8]] = k[9:]
-                        else:
-                            self.info[k] = ""
-                    elif s[0] == "%":
-                        # handle non-DSC PostScript comments that some
-                        # tools mistakenly put in the Comments section
-                        pass
-                    else:
-                        raise OSError("bad EPS header")
-
-            s_raw = fp.readline()
-            s = s_raw.strip("\r\n")
-
-            if s and s[:1] != "%":
-                break
-
-        #
-        # Scan for an "ImageData" descriptor
-
-        while s[:1] == "%":
-
-            if len(s) > 255:
-                raise SyntaxError("not an EPS file")
-
-            if s[:11] == "%ImageData:":
-                # Encoded bitmapped image.
-                x, y, bi, mo = s[11:].split(None, 7)[:4]
-
-                if int(bi) == 1:
-                    self.mode = "1"
-                elif int(bi) == 8:
-                    try:
-                        self.mode = self.mode_map[int(mo)]
-                    except ValueError:
-                        break
-                else:
-                    break
-
-                self._size = int(x), int(y)
-                return
-
-            s = fp.readline().strip("\r\n")
-            if not s:
-                break
-
-        if not box:
-            raise OSError("cannot determine EPS bounding box")
-
-    def _find_offset(self, fp):
-
-        s = fp.read(160)
-
-        if s[:4] == b"%!PS":
-            # for HEAD without binary preview
-            fp.seek(0, io.SEEK_END)
-            length = fp.tell()
-            offset = 0
-        elif i32(s, 0) == 0xC6D3D0C5:
-            # FIX for: Some EPS file not handled correctly / issue #302
-            # EPS can contain binary data
-            # or start directly with latin coding
-            # more info see:
-            # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
-            offset = i32(s, 4)
-            length = i32(s, 8)
-        else:
-            raise SyntaxError("not an EPS file")
-
-        return length, offset
-
-    def load(self, scale=1, transparency=False):
-        # Load EPS via Ghostscript
-        if self.tile:
-            self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
-            self.mode = self.im.mode
-            self._size = self.im.size
-            self.tile = []
-        return Image.Image.load(self)
-
-    def load_seek(self, *args, **kwargs):
-        # we can't incrementally load, so force ImageFile.parser to
-        # use our custom load method by defining this method.
-        pass
-
-
-#
-# --------------------------------------------------------------------
-
-
-def _save(im, fp, filename, eps=1):
-    """EPS Writer for the Python Imaging Library."""
-
-    #
-    # make sure image data is available
-    im.load()
-
-    #
-    # determine PostScript image mode
-    if im.mode == "L":
-        operator = (8, 1, b"image")
-    elif im.mode == "RGB":
-        operator = (8, 3, b"false 3 colorimage")
-    elif im.mode == "CMYK":
-        operator = (8, 4, b"false 4 colorimage")
-    else:
-        raise ValueError("image mode is not supported")
-
-    if eps:
-        #
-        # write EPS header
-        fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
-        fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
-        # fp.write("%%CreationDate: %s"...)
-        fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
-        fp.write(b"%%Pages: 1\n")
-        fp.write(b"%%EndComments\n")
-        fp.write(b"%%Page: 1 1\n")
-        fp.write(b"%%ImageData: %d %d " % im.size)
-        fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
-
-    #
-    # image header
-    fp.write(b"gsave\n")
-    fp.write(b"10 dict begin\n")
-    fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
-    fp.write(b"%d %d scale\n" % im.size)
-    fp.write(b"%d %d 8\n" % im.size)  # <= bits
-    fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
-    fp.write(b"{ currentfile buf readhexstring pop } bind\n")
-    fp.write(operator[2] + b"\n")
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-    ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
-
-    fp.write(b"\n%%%%EndBinary\n")
-    fp.write(b"grestore end\n")
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-
-#
-# --------------------------------------------------------------------
-
-
-Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
-
-Image.register_save(EpsImageFile.format, _save)
-
-Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
-
-Image.register_mime(EpsImageFile.format, "application/postscript")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ExifTags.py

@@ -1,340 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# EXIF tags
-#
-# Copyright (c) 2003 by Secret Labs AB
-#
-# See the README file for information on usage and redistribution.
-#
-
-"""
-This module provides constants and clear-text names for various
-well-known EXIF tags.
-"""
-
-from enum import IntEnum
-
-
-class Base(IntEnum):
-    # possibly incomplete
-    InteropIndex = 0x0001
-    ProcessingSoftware = 0x000B
-    NewSubfileType = 0x00FE
-    SubfileType = 0x00FF
-    ImageWidth = 0x0100
-    ImageLength = 0x0101
-    BitsPerSample = 0x0102
-    Compression = 0x0103
-    PhotometricInterpretation = 0x0106
-    Thresholding = 0x0107
-    CellWidth = 0x0108
-    CellLength = 0x0109
-    FillOrder = 0x010A
-    DocumentName = 0x010D
-    ImageDescription = 0x010E
-    Make = 0x010F
-    Model = 0x0110
-    StripOffsets = 0x0111
-    Orientation = 0x0112
-    SamplesPerPixel = 0x0115
-    RowsPerStrip = 0x0116
-    StripByteCounts = 0x0117
-    MinSampleValue = 0x0118
-    MaxSampleValue = 0x0119
-    XResolution = 0x011A
-    YResolution = 0x011B
-    PlanarConfiguration = 0x011C
-    PageName = 0x011D
-    FreeOffsets = 0x0120
-    FreeByteCounts = 0x0121
-    GrayResponseUnit = 0x0122
-    GrayResponseCurve = 0x0123
-    T4Options = 0x0124
-    T6Options = 0x0125
-    ResolutionUnit = 0x0128
-    PageNumber = 0x0129
-    TransferFunction = 0x012D
-    Software = 0x0131
-    DateTime = 0x0132
-    Artist = 0x013B
-    HostComputer = 0x013C
-    Predictor = 0x013D
-    WhitePoint = 0x013E
-    PrimaryChromaticities = 0x013F
-    ColorMap = 0x0140
-    HalftoneHints = 0x0141
-    TileWidth = 0x0142
-    TileLength = 0x0143
-    TileOffsets = 0x0144
-    TileByteCounts = 0x0145
-    SubIFDs = 0x014A
-    InkSet = 0x014C
-    InkNames = 0x014D
-    NumberOfInks = 0x014E
-    DotRange = 0x0150
-    TargetPrinter = 0x0151
-    ExtraSamples = 0x0152
-    SampleFormat = 0x0153
-    SMinSampleValue = 0x0154
-    SMaxSampleValue = 0x0155
-    TransferRange = 0x0156
-    ClipPath = 0x0157
-    XClipPathUnits = 0x0158
-    YClipPathUnits = 0x0159
-    Indexed = 0x015A
-    JPEGTables = 0x015B
-    OPIProxy = 0x015F
-    JPEGProc = 0x0200
-    JpegIFOffset = 0x0201
-    JpegIFByteCount = 0x0202
-    JpegRestartInterval = 0x0203
-    JpegLosslessPredictors = 0x0205
-    JpegPointTransforms = 0x0206
-    JpegQTables = 0x0207
-    JpegDCTables = 0x0208
-    JpegACTables = 0x0209
-    YCbCrCoefficients = 0x0211
-    YCbCrSubSampling = 0x0212
-    YCbCrPositioning = 0x0213
-    ReferenceBlackWhite = 0x0214
-    XMLPacket = 0x02BC
-    RelatedImageFileFormat = 0x1000
-    RelatedImageWidth = 0x1001
-    RelatedImageLength = 0x1002
-    Rating = 0x4746
-    RatingPercent = 0x4749
-    ImageID = 0x800D
-    CFARepeatPatternDim = 0x828D
-    BatteryLevel = 0x828F
-    Copyright = 0x8298
-    ExposureTime = 0x829A
-    FNumber = 0x829D
-    IPTCNAA = 0x83BB
-    ImageResources = 0x8649
-    ExifOffset = 0x8769
-    InterColorProfile = 0x8773
-    ExposureProgram = 0x8822
-    SpectralSensitivity = 0x8824
-    GPSInfo = 0x8825
-    ISOSpeedRatings = 0x8827
-    OECF = 0x8828
-    Interlace = 0x8829
-    TimeZoneOffset = 0x882A
-    SelfTimerMode = 0x882B
-    SensitivityType = 0x8830
-    StandardOutputSensitivity = 0x8831
-    RecommendedExposureIndex = 0x8832
-    ISOSpeed = 0x8833
-    ISOSpeedLatitudeyyy = 0x8834
-    ISOSpeedLatitudezzz = 0x8835
-    ExifVersion = 0x9000
-    DateTimeOriginal = 0x9003
-    DateTimeDigitized = 0x9004
-    OffsetTime = 0x9010
-    OffsetTimeOriginal = 0x9011
-    OffsetTimeDigitized = 0x9012
-    ComponentsConfiguration = 0x9101
-    CompressedBitsPerPixel = 0x9102
-    ShutterSpeedValue = 0x9201
-    ApertureValue = 0x9202
-    BrightnessValue = 0x9203
-    ExposureBiasValue = 0x9204
-    MaxApertureValue = 0x9205
-    SubjectDistance = 0x9206
-    MeteringMode = 0x9207
-    LightSource = 0x9208
-    Flash = 0x9209
-    FocalLength = 0x920A
-    Noise = 0x920D
-    ImageNumber = 0x9211
-    SecurityClassification = 0x9212
-    ImageHistory = 0x9213
-    TIFFEPStandardID = 0x9216
-    MakerNote = 0x927C
-    UserComment = 0x9286
-    SubsecTime = 0x9290
-    SubsecTimeOriginal = 0x9291
-    SubsecTimeDigitized = 0x9292
-    AmbientTemperature = 0x9400
-    Humidity = 0x9401
-    Pressure = 0x9402
-    WaterDepth = 0x9403
-    Acceleration = 0x9404
-    CameraElevationAngle = 0x9405
-    XPTitle = 0x9C9B
-    XPComment = 0x9C9C
-    XPAuthor = 0x9C9D
-    XPKeywords = 0x9C9E
-    XPSubject = 0x9C9F
-    FlashPixVersion = 0xA000
-    ColorSpace = 0xA001
-    ExifImageWidth = 0xA002
-    ExifImageHeight = 0xA003
-    RelatedSoundFile = 0xA004
-    ExifInteroperabilityOffset = 0xA005
-    FlashEnergy = 0xA20B
-    SpatialFrequencyResponse = 0xA20C
-    FocalPlaneXResolution = 0xA20E
-    FocalPlaneYResolution = 0xA20F
-    FocalPlaneResolutionUnit = 0xA210
-    SubjectLocation = 0xA214
-    ExposureIndex = 0xA215
-    SensingMethod = 0xA217
-    FileSource = 0xA300
-    SceneType = 0xA301
-    CFAPattern = 0xA302
-    CustomRendered = 0xA401
-    ExposureMode = 0xA402
-    WhiteBalance = 0xA403
-    DigitalZoomRatio = 0xA404
-    FocalLengthIn35mmFilm = 0xA405
-    SceneCaptureType = 0xA406
-    GainControl = 0xA407
-    Contrast = 0xA408
-    Saturation = 0xA409
-    Sharpness = 0xA40A
-    DeviceSettingDescription = 0xA40B
-    SubjectDistanceRange = 0xA40C
-    ImageUniqueID = 0xA420
-    CameraOwnerName = 0xA430
-    BodySerialNumber = 0xA431
-    LensSpecification = 0xA432
-    LensMake = 0xA433
-    LensModel = 0xA434
-    LensSerialNumber = 0xA435
-    CompositeImage = 0xA460
-    CompositeImageCount = 0xA461
-    CompositeImageExposureTimes = 0xA462
-    Gamma = 0xA500
-    PrintImageMatching = 0xC4A5
-    DNGVersion = 0xC612
-    DNGBackwardVersion = 0xC613
-    UniqueCameraModel = 0xC614
-    LocalizedCameraModel = 0xC615
-    CFAPlaneColor = 0xC616
-    CFALayout = 0xC617
-    LinearizationTable = 0xC618
-    BlackLevelRepeatDim = 0xC619
-    BlackLevel = 0xC61A
-    BlackLevelDeltaH = 0xC61B
-    BlackLevelDeltaV = 0xC61C
-    WhiteLevel = 0xC61D
-    DefaultScale = 0xC61E
-    DefaultCropOrigin = 0xC61F
-    DefaultCropSize = 0xC620
-    ColorMatrix1 = 0xC621
-    ColorMatrix2 = 0xC622
-    CameraCalibration1 = 0xC623
-    CameraCalibration2 = 0xC624
-    ReductionMatrix1 = 0xC625
-    ReductionMatrix2 = 0xC626
-    AnalogBalance = 0xC627
-    AsShotNeutral = 0xC628
-    AsShotWhiteXY = 0xC629
-    BaselineExposure = 0xC62A
-    BaselineNoise = 0xC62B
-    BaselineSharpness = 0xC62C
-    BayerGreenSplit = 0xC62D
-    LinearResponseLimit = 0xC62E
-    CameraSerialNumber = 0xC62F
-    LensInfo = 0xC630
-    ChromaBlurRadius = 0xC631
-    AntiAliasStrength = 0xC632
-    ShadowScale = 0xC633
-    DNGPrivateData = 0xC634
-    MakerNoteSafety = 0xC635
-    CalibrationIlluminant1 = 0xC65A
-    CalibrationIlluminant2 = 0xC65B
-    BestQualityScale = 0xC65C
-    RawDataUniqueID = 0xC65D
-    OriginalRawFileName = 0xC68B
-    OriginalRawFileData = 0xC68C
-    ActiveArea = 0xC68D
-    MaskedAreas = 0xC68E
-    AsShotICCProfile = 0xC68F
-    AsShotPreProfileMatrix = 0xC690
-    CurrentICCProfile = 0xC691
-    CurrentPreProfileMatrix = 0xC692
-    ColorimetricReference = 0xC6BF
-    CameraCalibrationSignature = 0xC6F3
-    ProfileCalibrationSignature = 0xC6F4
-    AsShotProfileName = 0xC6F6
-    NoiseReductionApplied = 0xC6F7
-    ProfileName = 0xC6F8
-    ProfileHueSatMapDims = 0xC6F9
-    ProfileHueSatMapData1 = 0xC6FA
-    ProfileHueSatMapData2 = 0xC6FB
-    ProfileToneCurve = 0xC6FC
-    ProfileEmbedPolicy = 0xC6FD
-    ProfileCopyright = 0xC6FE
-    ForwardMatrix1 = 0xC714
-    ForwardMatrix2 = 0xC715
-    PreviewApplicationName = 0xC716
-    PreviewApplicationVersion = 0xC717
-    PreviewSettingsName = 0xC718
-    PreviewSettingsDigest = 0xC719
-    PreviewColorSpace = 0xC71A
-    PreviewDateTime = 0xC71B
-    RawImageDigest = 0xC71C
-    OriginalRawFileDigest = 0xC71D
-    SubTileBlockSize = 0xC71E
-    RowInterleaveFactor = 0xC71F
-    ProfileLookTableDims = 0xC725
-    ProfileLookTableData = 0xC726
-    OpcodeList1 = 0xC740
-    OpcodeList2 = 0xC741
-    OpcodeList3 = 0xC74E
-    NoiseProfile = 0xC761
-
-
-"""Maps EXIF tags to tag names."""
-TAGS = {
-    **{i.value: i.name for i in Base},
-    0x920C: "SpatialFrequencyResponse",
-    0x9214: "SubjectLocation",
-    0x9215: "ExposureIndex",
-    0x828E: "CFAPattern",
-    0x920B: "FlashEnergy",
-    0x9216: "TIFF/EPStandardID",
-}
-
-
-class GPS(IntEnum):
-    GPSVersionID = 0
-    GPSLatitudeRef = 1
-    GPSLatitude = 2
-    GPSLongitudeRef = 3
-    GPSLongitude = 4
-    GPSAltitudeRef = 5
-    GPSAltitude = 6
-    GPSTimeStamp = 7
-    GPSSatellites = 8
-    GPSStatus = 9
-    GPSMeasureMode = 10
-    GPSDOP = 11
-    GPSSpeedRef = 12
-    GPSSpeed = 13
-    GPSTrackRef = 14
-    GPSTrack = 15
-    GPSImgDirectionRef = 16
-    GPSImgDirection = 17
-    GPSMapDatum = 18
-    GPSDestLatitudeRef = 19
-    GPSDestLatitude = 20
-    GPSDestLongitudeRef = 21
-    GPSDestLongitude = 22
-    GPSDestBearingRef = 23
-    GPSDestBearing = 24
-    GPSDestDistanceRef = 25
-    GPSDestDistance = 26
-    GPSProcessingMethod = 27
-    GPSAreaInformation = 28
-    GPSDateStamp = 29
-    GPSDifferential = 30
-    GPSHPositioningError = 31
-
-
-"""Maps EXIF GPS tags to tag names."""
-GPSTAGS = {i.value: i.name for i in GPS}

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FitsImagePlugin.py

@@ -1,71 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# FITS file handling
-#
-# Copyright (c) 1998-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import math
-
-from . import Image, ImageFile
-
-
-def _accept(prefix):
-    return prefix[:6] == b"SIMPLE"
-
-
-class FitsImageFile(ImageFile.ImageFile):
-
-    format = "FITS"
-    format_description = "FITS"
-
-    def _open(self):
-        headers = {}
-        while True:
-            header = self.fp.read(80)
-            if not header:
-                raise OSError("Truncated FITS file")
-            keyword = header[:8].strip()
-            if keyword == b"END":
-                break
-            value = header[8:].strip()
-            if value.startswith(b"="):
-                value = value[1:].strip()
-            if not headers and (not _accept(keyword) or value != b"T"):
-                raise SyntaxError("Not a FITS file")
-            headers[keyword] = value
-
-        naxis = int(headers[b"NAXIS"])
-        if naxis == 0:
-            raise ValueError("No image data")
-        elif naxis == 1:
-            self._size = 1, int(headers[b"NAXIS1"])
-        else:
-            self._size = int(headers[b"NAXIS1"]), int(headers[b"NAXIS2"])
-
-        number_of_bits = int(headers[b"BITPIX"])
-        if number_of_bits == 8:
-            self.mode = "L"
-        elif number_of_bits == 16:
-            self.mode = "I"
-            # rawmode = "I;16S"
-        elif number_of_bits == 32:
-            self.mode = "I"
-        elif number_of_bits in (-32, -64):
-            self.mode = "F"
-            # rawmode = "F" if number_of_bits == -32 else "F;64F"
-
-        offset = math.ceil(self.fp.tell() / 2880) * 2880
-        self.tile = [("raw", (0, 0) + self.size, offset, (self.mode, 0, -1))]
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_open(FitsImageFile.format, FitsImageFile, _accept)
-
-Image.register_extensions(FitsImageFile.format, [".fit", ".fits"])

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FitsStubImagePlugin.py

@@ -1,76 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# FITS stub adapter
-#
-# Copyright (c) 1998-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import FitsImagePlugin, Image, ImageFile
-from ._deprecate import deprecate
-
-_handler = None
-
-
-def register_handler(handler):
-    """
-    Install application-specific FITS image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-    deprecate(
-        "FitsStubImagePlugin",
-        10,
-        action="FITS images can now be read without "
-        "a handler through FitsImagePlugin instead",
-    )
-
-    # Override FitsImagePlugin with this handler
-    # for backwards compatibility
-    try:
-        Image.ID.remove(FITSStubImageFile.format)
-    except ValueError:
-        pass
-
-    Image.register_open(
-        FITSStubImageFile.format, FITSStubImageFile, FitsImagePlugin._accept
-    )
-
-
-class FITSStubImageFile(ImageFile.StubImageFile):
-
-    format = FitsImagePlugin.FitsImageFile.format
-    format_description = FitsImagePlugin.FitsImageFile.format_description
-
-    def _open(self):
-        offset = self.fp.tell()
-
-        im = FitsImagePlugin.FitsImageFile(self.fp)
-        self._size = im.size
-        self.mode = im.mode
-        self.tile = []
-
-        self.fp.seek(offset)
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self):
-        return _handler
-
-
-def _save(im, fp, filename):
-    raise OSError("FITS save handler not installed")
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_save(FITSStubImageFile.format, _save)

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FliImagePlugin.py

@@ -1,171 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# FLI/FLC file handling.
-#
-# History:
-#       95-09-01 fl     Created
-#       97-01-03 fl     Fixed parser, setup decoder tile
-#       98-07-15 fl     Renamed offset attribute to avoid name clash
-#
-# Copyright (c) Secret Labs AB 1997-98.
-# Copyright (c) Fredrik Lundh 1995-97.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import os
-
-from . import Image, ImageFile, ImagePalette
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-from ._binary import o8
-
-#
-# decoder
-
-
-def _accept(prefix):
-    return (
-        len(prefix) >= 6
-        and i16(prefix, 4) in [0xAF11, 0xAF12]
-        and i16(prefix, 14) in [0, 3]  # flags
-    )
-
-
-##
-# Image plugin for the FLI/FLC animation format.  Use the <b>seek</b>
-# method to load individual frames.
-
-
-class FliImageFile(ImageFile.ImageFile):
-
-    format = "FLI"
-    format_description = "Autodesk FLI/FLC Animation"
-    _close_exclusive_fp_after_loading = False
-
-    def _open(self):
-
-        # HEAD
-        s = self.fp.read(128)
-        if not (_accept(s) and s[20:22] == b"\x00\x00"):
-            raise SyntaxError("not an FLI/FLC file")
-
-        # frames
-        self.n_frames = i16(s, 6)
-        self.is_animated = self.n_frames > 1
-
-        # image characteristics
-        self.mode = "P"
-        self._size = i16(s, 8), i16(s, 10)
-
-        # animation speed
-        duration = i32(s, 16)
-        magic = i16(s, 4)
-        if magic == 0xAF11:
-            duration = (duration * 1000) // 70
-        self.info["duration"] = duration
-
-        # look for palette
-        palette = [(a, a, a) for a in range(256)]
-
-        s = self.fp.read(16)
-
-        self.__offset = 128
-
-        if i16(s, 4) == 0xF100:
-            # prefix chunk; ignore it
-            self.__offset = self.__offset + i32(s)
-            s = self.fp.read(16)
-
-        if i16(s, 4) == 0xF1FA:
-            # look for palette chunk
-            number_of_subchunks = i16(s, 6)
-            chunk_size = None
-            for _ in range(number_of_subchunks):
-                if chunk_size is not None:
-                    self.fp.seek(chunk_size - 6, os.SEEK_CUR)
-                s = self.fp.read(6)
-                chunk_type = i16(s, 4)
-                if chunk_type in (4, 11):
-                    self._palette(palette, 2 if chunk_type == 11 else 0)
-                    break
-                chunk_size = i32(s)
-                if not chunk_size:
-                    break
-
-        palette = [o8(r) + o8(g) + o8(b) for (r, g, b) in palette]
-        self.palette = ImagePalette.raw("RGB", b"".join(palette))
-
-        # set things up to decode first frame
-        self.__frame = -1
-        self._fp = self.fp
-        self.__rewind = self.fp.tell()
-        self.seek(0)
-
-    def _palette(self, palette, shift):
-        # load palette
-
-        i = 0
-        for e in range(i16(self.fp.read(2))):
-            s = self.fp.read(2)
-            i = i + s[0]
-            n = s[1]
-            if n == 0:
-                n = 256
-            s = self.fp.read(n * 3)
-            for n in range(0, len(s), 3):
-                r = s[n] << shift
-                g = s[n + 1] << shift
-                b = s[n + 2] << shift
-                palette[i] = (r, g, b)
-                i += 1
-
-    def seek(self, frame):
-        if not self._seek_check(frame):
-            return
-        if frame < self.__frame:
-            self._seek(0)
-
-        for f in range(self.__frame + 1, frame + 1):
-            self._seek(f)
-
-    def _seek(self, frame):
-        if frame == 0:
-            self.__frame = -1
-            self._fp.seek(self.__rewind)
-            self.__offset = 128
-        else:
-            # ensure that the previous frame was loaded
-            self.load()
-
-        if frame != self.__frame + 1:
-            raise ValueError(f"cannot seek to frame {frame}")
-        self.__frame = frame
-
-        # move to next frame
-        self.fp = self._fp
-        self.fp.seek(self.__offset)
-
-        s = self.fp.read(4)
-        if not s:
-            raise EOFError
-
-        framesize = i32(s)
-
-        self.decodermaxblock = framesize
-        self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
-
-        self.__offset += framesize
-
-    def tell(self):
-        return self.__frame
-
-
-#
-# registry
-
-Image.register_open(FliImageFile.format, FliImageFile, _accept)
-
-Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FontFile.py

@@ -1,111 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# base class for raster font file parsers
-#
-# history:
-# 1997-06-05 fl   created
-# 1997-08-19 fl   restrict image width
-#
-# Copyright (c) 1997-1998 by Secret Labs AB
-# Copyright (c) 1997-1998 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-import os
-
-from . import Image, _binary
-
-WIDTH = 800
-
-
-def puti16(fp, values):
-    """Write network order (big-endian) 16-bit sequence"""
-    for v in values:
-        if v < 0:
-            v += 65536
-        fp.write(_binary.o16be(v))
-
-
-class FontFile:
-    """Base class for raster font file handlers."""
-
-    bitmap = None
-
-    def __init__(self):
-
-        self.info = {}
-        self.glyph = [None] * 256
-
-    def __getitem__(self, ix):
-        return self.glyph[ix]
-
-    def compile(self):
-        """Create metrics and bitmap"""
-
-        if self.bitmap:
-            return
-
-        # create bitmap large enough to hold all data
-        h = w = maxwidth = 0
-        lines = 1
-        for glyph in self:
-            if glyph:
-                d, dst, src, im = glyph
-                h = max(h, src[3] - src[1])
-                w = w + (src[2] - src[0])
-                if w > WIDTH:
-                    lines += 1
-                    w = src[2] - src[0]
-                maxwidth = max(maxwidth, w)
-
-        xsize = maxwidth
-        ysize = lines * h
-
-        if xsize == 0 and ysize == 0:
-            return ""
-
-        self.ysize = h
-
-        # paste glyphs into bitmap
-        self.bitmap = Image.new("1", (xsize, ysize))
-        self.metrics = [None] * 256
-        x = y = 0
-        for i in range(256):
-            glyph = self[i]
-            if glyph:
-                d, dst, src, im = glyph
-                xx = src[2] - src[0]
-                # yy = src[3] - src[1]
-                x0, y0 = x, y
-                x = x + xx
-                if x > WIDTH:
-                    x, y = 0, y + h
-                    x0, y0 = x, y
-                    x = xx
-                s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
-                self.bitmap.paste(im.crop(src), s)
-                self.metrics[i] = d, dst, s
-
-    def save(self, filename):
-        """Save font"""
-
-        self.compile()
-
-        # font data
-        self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
-
-        # font metrics
-        with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
-            fp.write(b"PILfont\n")
-            fp.write(f";;;;;;{self.ysize};\n".encode("ascii"))  # HACK!!!
-            fp.write(b"DATA\n")
-            for id in range(256):
-                m = self.metrics[id]
-                if not m:
-                    puti16(fp, [0] * 10)
-                else:
-                    puti16(fp, m[0] + m[1] + m[2])

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FpxImagePlugin.py

@@ -1,245 +0,0 @@
-#
-# THIS IS WORK IN PROGRESS
-#
-# The Python Imaging Library.
-# $Id$
-#
-# FlashPix support for PIL
-#
-# History:
-# 97-01-25 fl   Created (reads uncompressed RGB images only)
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1997.
-#
-# See the README file for information on usage and redistribution.
-#
-import olefile
-
-from . import Image, ImageFile
-from ._binary import i32le as i32
-
-# we map from colour field tuples to (mode, rawmode) descriptors
-MODES = {
-    # opacity
-    (0x00007FFE,): ("A", "L"),
-    # monochrome
-    (0x00010000,): ("L", "L"),
-    (0x00018000, 0x00017FFE): ("RGBA", "LA"),
-    # photo YCC
-    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
-    (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
-    # standard RGB (NIFRGB)
-    (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
-    (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
-}
-
-
-#
-# --------------------------------------------------------------------
-
-
-def _accept(prefix):
-    return prefix[:8] == olefile.MAGIC
-
-
-##
-# Image plugin for the FlashPix images.
-
-
-class FpxImageFile(ImageFile.ImageFile):
-
-    format = "FPX"
-    format_description = "FlashPix"
-
-    def _open(self):
-        #
-        # read the OLE directory and see if this is a likely
-        # to be a FlashPix file
-
-        try:
-            self.ole = olefile.OleFileIO(self.fp)
-        except OSError as e:
-            raise SyntaxError("not an FPX file; invalid OLE file") from e
-
-        if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
-            raise SyntaxError("not an FPX file; bad root CLSID")
-
-        self._open_index(1)
-
-    def _open_index(self, index=1):
-        #
-        # get the Image Contents Property Set
-
-        prop = self.ole.getproperties(
-            [f"Data Object Store {index:06d}", "\005Image Contents"]
-        )
-
-        # size (highest resolution)
-
-        self._size = prop[0x1000002], prop[0x1000003]
-
-        size = max(self.size)
-        i = 1
-        while size > 64:
-            size = size / 2
-            i += 1
-        self.maxid = i - 1
-
-        # mode.  instead of using a single field for this, flashpix
-        # requires you to specify the mode for each channel in each
-        # resolution subimage, and leaves it to the decoder to make
-        # sure that they all match.  for now, we'll cheat and assume
-        # that this is always the case.
-
-        id = self.maxid << 16
-
-        s = prop[0x2000002 | id]
-
-        colors = []
-        bands = i32(s, 4)
-        if bands > 4:
-            raise OSError("Invalid number of bands")
-        for i in range(bands):
-            # note: for now, we ignore the "uncalibrated" flag
-            colors.append(i32(s, 8 + i * 4) & 0x7FFFFFFF)
-
-        self.mode, self.rawmode = MODES[tuple(colors)]
-
-        # load JPEG tables, if any
-        self.jpeg = {}
-        for i in range(256):
-            id = 0x3000001 | (i << 16)
-            if id in prop:
-                self.jpeg[i] = prop[id]
-
-        self._open_subimage(1, self.maxid)
-
-    def _open_subimage(self, index=1, subimage=0):
-        #
-        # setup tile descriptors for a given subimage
-
-        stream = [
-            f"Data Object Store {index:06d}",
-            f"Resolution {subimage:04d}",
-            "Subimage 0000 Header",
-        ]
-
-        fp = self.ole.openstream(stream)
-
-        # skip prefix
-        fp.read(28)
-
-        # header stream
-        s = fp.read(36)
-
-        size = i32(s, 4), i32(s, 8)
-        # tilecount = i32(s, 12)
-        tilesize = i32(s, 16), i32(s, 20)
-        # channels = i32(s, 24)
-        offset = i32(s, 28)
-        length = i32(s, 32)
-
-        if size != self.size:
-            raise OSError("subimage mismatch")
-
-        # get tile descriptors
-        fp.seek(28 + offset)
-        s = fp.read(i32(s, 12) * length)
-
-        x = y = 0
-        xsize, ysize = size
-        xtile, ytile = tilesize
-        self.tile = []
-
-        for i in range(0, len(s), length):
-
-            x1 = min(xsize, x + xtile)
-            y1 = min(ysize, y + ytile)
-
-            compression = i32(s, i + 8)
-
-            if compression == 0:
-                self.tile.append(
-                    (
-                        "raw",
-                        (x, y, x1, y1),
-                        i32(s, i) + 28,
-                        (self.rawmode,),
-                    )
-                )
-
-            elif compression == 1:
-
-                # FIXME: the fill decoder is not implemented
-                self.tile.append(
-                    (
-                        "fill",
-                        (x, y, x1, y1),
-                        i32(s, i) + 28,
-                        (self.rawmode, s[12:16]),
-                    )
-                )
-
-            elif compression == 2:
-
-                internal_color_conversion = s[14]
-                jpeg_tables = s[15]
-                rawmode = self.rawmode
-
-                if internal_color_conversion:
-                    # The image is stored as usual (usually YCbCr).
-                    if rawmode == "RGBA":
-                        # For "RGBA", data is stored as YCbCrA based on
-                        # negative RGB. The following trick works around
-                        # this problem :
-                        jpegmode, rawmode = "YCbCrK", "CMYK"
-                    else:
-                        jpegmode = None  # let the decoder decide
-
-                else:
-                    # The image is stored as defined by rawmode
-                    jpegmode = rawmode
-
-                self.tile.append(
-                    (
-                        "jpeg",
-                        (x, y, x1, y1),
-                        i32(s, i) + 28,
-                        (rawmode, jpegmode),
-                    )
-                )
-
-                # FIXME: jpeg tables are tile dependent; the prefix
-                # data must be placed in the tile descriptor itself!
-
-                if jpeg_tables:
-                    self.tile_prefix = self.jpeg[jpeg_tables]
-
-            else:
-                raise OSError("unknown/invalid compression")
-
-            x = x + xtile
-            if x >= xsize:
-                x, y = 0, y + ytile
-                if y >= ysize:
-                    break  # isn't really required
-
-        self.stream = stream
-        self.fp = None
-
-    def load(self):
-
-        if not self.fp:
-            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
-
-        return ImageFile.ImageFile.load(self)
-
-
-#
-# --------------------------------------------------------------------
-
-
-Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
-
-Image.register_extension(FpxImageFile.format, ".fpx")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/FtexImagePlugin.py

@@ -1,122 +0,0 @@
-"""
-A Pillow loader for .ftc and .ftu files (FTEX)
-Jerome Leclanche <jerome@leclan.ch>
-
-The contents of this file are hereby released in the public domain (CC0)
-Full text of the CC0 license:
-  https://creativecommons.org/publicdomain/zero/1.0/
-
-Independence War 2: Edge Of Chaos - Texture File Format - 16 October 2001
-
-The textures used for 3D objects in Independence War 2: Edge Of Chaos are in a
-packed custom format called FTEX. This file format uses file extensions FTC
-and FTU.
-* FTC files are compressed textures (using standard texture compression).
-* FTU files are not compressed.
-Texture File Format
-The FTC and FTU texture files both use the same format. This
-has the following structure:
-{header}
-{format_directory}
-{data}
-Where:
-{header} = {
-    u32:magic,
-    u32:version,
-    u32:width,
-    u32:height,
-    u32:mipmap_count,
-    u32:format_count
-}
-
-* The "magic" number is "FTEX".
-* "width" and "height" are the dimensions of the texture.
-* "mipmap_count" is the number of mipmaps in the texture.
-* "format_count" is the number of texture formats (different versions of the
-same texture) in this file.
-
-{format_directory} = format_count * { u32:format, u32:where }
-
-The format value is 0 for DXT1 compressed textures and 1 for 24-bit RGB
-uncompressed textures.
-The texture data for a format starts at the position "where" in the file.
-
-Each set of texture data in the file has the following structure:
-{data} = format_count * { u32:mipmap_size, mipmap_size * { u8 } }
-* "mipmap_size" is the number of bytes in that mip level. For compressed
-textures this is the size of the texture data compressed with DXT1. For 24 bit
-uncompressed textures, this is 3 * width * height. Following this are the image
-bytes for that mipmap level.
-
-Note: All data is stored in little-Endian (Intel) byte order.
-"""
-
-import struct
-from enum import IntEnum
-from io import BytesIO
-
-from . import Image, ImageFile
-from ._deprecate import deprecate
-
-MAGIC = b"FTEX"
-
-
-class Format(IntEnum):
-    DXT1 = 0
-    UNCOMPRESSED = 1
-
-
-def __getattr__(name):
-    for enum, prefix in {Format: "FORMAT_"}.items():
-        if name.startswith(prefix):
-            name = name[len(prefix) :]
-            if name in enum.__members__:
-                deprecate(f"{prefix}{name}", 10, f"{enum.__name__}.{name}")
-                return enum[name]
-    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-class FtexImageFile(ImageFile.ImageFile):
-    format = "FTEX"
-    format_description = "Texture File Format (IW2:EOC)"
-
-    def _open(self):
-        if not _accept(self.fp.read(4)):
-            raise SyntaxError("not an FTEX file")
-        struct.unpack("<i", self.fp.read(4))  # version
-        self._size = struct.unpack("<2i", self.fp.read(8))
-        mipmap_count, format_count = struct.unpack("<2i", self.fp.read(8))
-
-        self.mode = "RGB"
-
-        # Only support single-format files.
-        # I don't know of any multi-format file.
-        assert format_count == 1
-
-        format, where = struct.unpack("<2i", self.fp.read(8))
-        self.fp.seek(where)
-        (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
-
-        data = self.fp.read(mipmap_size)
-
-        if format == Format.DXT1:
-            self.mode = "RGBA"
-            self.tile = [("bcn", (0, 0) + self.size, 0, 1)]
-        elif format == Format.UNCOMPRESSED:
-            self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
-        else:
-            raise ValueError(f"Invalid texture compression format: {repr(format)}")
-
-        self.fp.close()
-        self.fp = BytesIO(data)
-
-    def load_seek(self, pos):
-        pass
-
-
-def _accept(prefix):
-    return prefix[:4] == MAGIC
-
-
-Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
-Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/GbrImagePlugin.py

@@ -1,98 +0,0 @@
-#
-# The Python Imaging Library
-#
-# load a GIMP brush file
-#
-# History:
-#       96-03-14 fl     Created
-#       16-01-08 es     Version 2
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-# Copyright (c) Eric Soroos 2016.
-#
-# See the README file for information on usage and redistribution.
-#
-#
-# See https://github.com/GNOME/gimp/blob/mainline/devel-docs/gbr.txt for
-# format documentation.
-#
-# This code Interprets version 1 and 2 .gbr files.
-# Version 1 files are obsolete, and should not be used for new
-#   brushes.
-# Version 2 files are saved by GIMP v2.8 (at least)
-# Version 3 files have a format specifier of 18 for 16bit floats in
-#   the color depth field. This is currently unsupported by Pillow.
-
-from . import Image, ImageFile
-from ._binary import i32be as i32
-
-
-def _accept(prefix):
-    return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
-
-
-##
-# Image plugin for the GIMP brush format.
-
-
-class GbrImageFile(ImageFile.ImageFile):
-
-    format = "GBR"
-    format_description = "GIMP brush file"
-
-    def _open(self):
-        header_size = i32(self.fp.read(4))
-        if header_size < 20:
-            raise SyntaxError("not a GIMP brush")
-        version = i32(self.fp.read(4))
-        if version not in (1, 2):
-            raise SyntaxError(f"Unsupported GIMP brush version: {version}")
-
-        width = i32(self.fp.read(4))
-        height = i32(self.fp.read(4))
-        color_depth = i32(self.fp.read(4))
-        if width <= 0 or height <= 0:
-            raise SyntaxError("not a GIMP brush")
-        if color_depth not in (1, 4):
-            raise SyntaxError(f"Unsupported GIMP brush color depth: {color_depth}")
-
-        if version == 1:
-            comment_length = header_size - 20
-        else:
-            comment_length = header_size - 28
-            magic_number = self.fp.read(4)
-            if magic_number != b"GIMP":
-                raise SyntaxError("not a GIMP brush, bad magic number")
-            self.info["spacing"] = i32(self.fp.read(4))
-
-        comment = self.fp.read(comment_length)[:-1]
-
-        if color_depth == 1:
-            self.mode = "L"
-        else:
-            self.mode = "RGBA"
-
-        self._size = width, height
-
-        self.info["comment"] = comment
-
-        # Image might not be small
-        Image._decompression_bomb_check(self.size)
-
-        # Data is an uncompressed block of w * h * bytes/pixel
-        self._data_size = width * height * color_depth
-
-    def load(self):
-        if not self.im:
-            self.im = Image.core.new(self.mode, self.size)
-            self.frombytes(self.fp.read(self._data_size))
-        return Image.Image.load(self)
-
-
-#
-# registry
-
-
-Image.register_open(GbrImageFile.format, GbrImageFile, _accept)
-Image.register_extension(GbrImageFile.format, ".gbr")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/GdImageFile.py

@@ -1,95 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# GD file handling
-#
-# History:
-# 1996-04-12 fl   Created
-#
-# Copyright (c) 1997 by Secret Labs AB.
-# Copyright (c) 1996 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-"""
-.. note::
-    This format cannot be automatically recognized, so the
-    class is not registered for use with :py:func:`PIL.Image.open()`.  To open a
-    gd file, use the :py:func:`PIL.GdImageFile.open()` function instead.
-
-.. warning::
-    THE GD FORMAT IS NOT DESIGNED FOR DATA INTERCHANGE.  This
-    implementation is provided for convenience and demonstrational
-    purposes only.
-"""
-
-
-from . import ImageFile, ImagePalette, UnidentifiedImageError
-from ._binary import i16be as i16
-from ._binary import i32be as i32
-
-
-class GdImageFile(ImageFile.ImageFile):
-    """
-    Image plugin for the GD uncompressed format.  Note that this format
-    is not supported by the standard :py:func:`PIL.Image.open()` function.  To use
-    this plugin, you have to import the :py:mod:`PIL.GdImageFile` module and
-    use the :py:func:`PIL.GdImageFile.open()` function.
-    """
-
-    format = "GD"
-    format_description = "GD uncompressed images"
-
-    def _open(self):
-
-        # Header
-        s = self.fp.read(1037)
-
-        if not i16(s) in [65534, 65535]:
-            raise SyntaxError("Not a valid GD 2.x .gd file")
-
-        self.mode = "L"  # FIXME: "P"
-        self._size = i16(s, 2), i16(s, 4)
-
-        true_color = s[6]
-        true_color_offset = 2 if true_color else 0
-
-        # transparency index
-        tindex = i32(s, 7 + true_color_offset)
-        if tindex < 256:
-            self.info["transparency"] = tindex
-
-        self.palette = ImagePalette.raw(
-            "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4]
-        )
-
-        self.tile = [
-            (
-                "raw",
-                (0, 0) + self.size,
-                7 + true_color_offset + 4 + 256 * 4,
-                ("L", 0, 1),
-            )
-        ]
-
-
-def open(fp, mode="r"):
-    """
-    Load texture from a GD image file.
-
-    :param fp: GD file name, or an opened file handle.
-    :param mode: Optional mode.  In this version, if the mode argument
-        is given, it must be "r".
-    :returns: An image instance.
-    :raises OSError: If the image could not be read.
-    """
-    if mode != "r":
-        raise ValueError("bad mode")
-
-    try:
-        return GdImageFile(fp)
-    except SyntaxError as e:
-        raise UnidentifiedImageError("cannot identify this image file") from e

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/GimpGradientFile.py

@@ -1,140 +0,0 @@
-#
-# Python Imaging Library
-# $Id$
-#
-# stuff to read (and render) GIMP gradient files
-#
-# History:
-#       97-08-23 fl     Created
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1997.
-#
-# See the README file for information on usage and redistribution.
-#
-
-"""
-Stuff to translate curve segments to palette values (derived from
-the corresponding code in GIMP, written by Federico Mena Quintero.
-See the GIMP distribution for more information.)
-"""
-
-
-from math import log, pi, sin, sqrt
-
-from ._binary import o8
-
-EPSILON = 1e-10
-""""""  # Enable auto-doc for data member
-
-
-def linear(middle, pos):
-    if pos <= middle:
-        if middle < EPSILON:
-            return 0.0
-        else:
-            return 0.5 * pos / middle
-    else:
-        pos = pos - middle
-        middle = 1.0 - middle
-        if middle < EPSILON:
-            return 1.0
-        else:
-            return 0.5 + 0.5 * pos / middle
-
-
-def curved(middle, pos):
-    return pos ** (log(0.5) / log(max(middle, EPSILON)))
-
-
-def sine(middle, pos):
-    return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
-
-
-def sphere_increasing(middle, pos):
-    return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
-
-
-def sphere_decreasing(middle, pos):
-    return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
-
-
-SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
-""""""  # Enable auto-doc for data member
-
-
-class GradientFile:
-
-    gradient = None
-
-    def getpalette(self, entries=256):
-
-        palette = []
-
-        ix = 0
-        x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
-
-        for i in range(entries):
-
-            x = i / (entries - 1)
-
-            while x1 < x:
-                ix += 1
-                x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
-
-            w = x1 - x0
-
-            if w < EPSILON:
-                scale = segment(0.5, 0.5)
-            else:
-                scale = segment((xm - x0) / w, (x - x0) / w)
-
-            # expand to RGBA
-            r = o8(int(255 * ((rgb1[0] - rgb0[0]) * scale + rgb0[0]) + 0.5))
-            g = o8(int(255 * ((rgb1[1] - rgb0[1]) * scale + rgb0[1]) + 0.5))
-            b = o8(int(255 * ((rgb1[2] - rgb0[2]) * scale + rgb0[2]) + 0.5))
-            a = o8(int(255 * ((rgb1[3] - rgb0[3]) * scale + rgb0[3]) + 0.5))
-
-            # add to palette
-            palette.append(r + g + b + a)
-
-        return b"".join(palette), "RGBA"
-
-
-class GimpGradientFile(GradientFile):
-    """File handler for GIMP's gradient format."""
-
-    def __init__(self, fp):
-
-        if fp.readline()[:13] != b"GIMP Gradient":
-            raise SyntaxError("not a GIMP gradient file")
-
-        line = fp.readline()
-
-        # GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
-        if line.startswith(b"Name: "):
-            line = fp.readline().strip()
-
-        count = int(line)
-
-        gradient = []
-
-        for i in range(count):
-
-            s = fp.readline().split()
-            w = [float(x) for x in s[:11]]
-
-            x0, x1 = w[0], w[2]
-            xm = w[1]
-            rgb0 = w[3:7]
-            rgb1 = w[7:11]
-
-            segment = SEGMENTS[int(s[11])]
-            cspace = int(s[12])
-
-            if cspace != 0:
-                raise OSError("cannot handle HSV colour space")
-
-            gradient.append((x0, x1, xm, rgb0, rgb1, segment))
-
-        self.gradient = gradient

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/GimpPaletteFile.py

@@ -1,56 +0,0 @@
-#
-# Python Imaging Library
-# $Id$
-#
-# stuff to read GIMP palette files
-#
-# History:
-# 1997-08-23 fl     Created
-# 2004-09-07 fl     Support GIMP 2.0 palette files.
-#
-# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
-# Copyright (c) Fredrik Lundh 1997-2004.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import re
-
-from ._binary import o8
-
-
-class GimpPaletteFile:
-    """File handler for GIMP's palette format."""
-
-    rawmode = "RGB"
-
-    def __init__(self, fp):
-
-        self.palette = [o8(i) * 3 for i in range(256)]
-
-        if fp.readline()[:12] != b"GIMP Palette":
-            raise SyntaxError("not a GIMP palette file")
-
-        for i in range(256):
-
-            s = fp.readline()
-            if not s:
-                break
-
-            # skip fields and comment lines
-            if re.match(rb"\w+:|#", s):
-                continue
-            if len(s) > 100:
-                raise SyntaxError("bad palette file")
-
-            v = tuple(map(int, s.split()[:3]))
-            if len(v) != 3:
-                raise ValueError("bad palette entry")
-
-            self.palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
-
-        self.palette = b"".join(self.palette)
-
-    def getpalette(self):
-
-        return self.palette, self.rawmode

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/GribStubImagePlugin.py

@@ -1,73 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# GRIB stub adapter
-#
-# Copyright (c) 1996-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler):
-    """
-    Install application-specific GRIB image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix):
-    return prefix[:4] == b"GRIB" and prefix[7] == 1
-
-
-class GribStubImageFile(ImageFile.StubImageFile):
-
-    format = "GRIB"
-    format_description = "GRIB"
-
-    def _open(self):
-
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(8)):
-            raise SyntaxError("Not a GRIB file")
-
-        self.fp.seek(offset)
-
-        # make something up
-        self.mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self):
-        return _handler
-
-
-def _save(im, fp, filename):
-    if _handler is None or not hasattr(_handler, "save"):
-        raise OSError("GRIB save handler not installed")
-    _handler.save(im, fp, filename)
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_open(GribStubImageFile.format, GribStubImageFile, _accept)
-Image.register_save(GribStubImageFile.format, _save)
-
-Image.register_extension(GribStubImageFile.format, ".grib")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/Hdf5StubImagePlugin.py

@@ -1,73 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# HDF5 stub adapter
-#
-# Copyright (c) 2000-2003 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler):
-    """
-    Install application-specific HDF5 image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix):
-    return prefix[:8] == b"\x89HDF\r\n\x1a\n"
-
-
-class HDF5StubImageFile(ImageFile.StubImageFile):
-
-    format = "HDF5"
-    format_description = "HDF5"
-
-    def _open(self):
-
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(8)):
-            raise SyntaxError("Not an HDF file")
-
-        self.fp.seek(offset)
-
-        # make something up
-        self.mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self):
-        return _handler
-
-
-def _save(im, fp, filename):
-    if _handler is None or not hasattr(_handler, "save"):
-        raise OSError("HDF5 save handler not installed")
-    _handler.save(im, fp, filename)
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_open(HDF5StubImageFile.format, HDF5StubImageFile, _accept)
-Image.register_save(HDF5StubImageFile.format, _save)
-
-Image.register_extensions(HDF5StubImageFile.format, [".h5", ".hdf"])

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/IcnsImagePlugin.py

@@ -1,392 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# macOS icns file decoder, based on icns.py by Bob Ippolito.
-#
-# history:
-# 2004-10-09 fl   Turned into a PIL plugin; removed 2.3 dependencies.
-# 2020-04-04      Allow saving on all operating systems.
-#
-# Copyright (c) 2004 by Bob Ippolito.
-# Copyright (c) 2004 by Secret Labs.
-# Copyright (c) 2004 by Fredrik Lundh.
-# Copyright (c) 2014 by Alastair Houghton.
-# Copyright (c) 2020 by Pan Jing.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import io
-import os
-import struct
-import sys
-
-from PIL import Image, ImageFile, PngImagePlugin, features
-
-enable_jpeg2k = features.check_codec("jpg_2000")
-if enable_jpeg2k:
-    from PIL import Jpeg2KImagePlugin
-
-MAGIC = b"icns"
-HEADERSIZE = 8
-
-
-def nextheader(fobj):
-    return struct.unpack(">4sI", fobj.read(HEADERSIZE))
-
-
-def read_32t(fobj, start_length, size):
-    # The 128x128 icon seems to have an extra header for some reason.
-    (start, length) = start_length
-    fobj.seek(start)
-    sig = fobj.read(4)
-    if sig != b"\x00\x00\x00\x00":
-        raise SyntaxError("Unknown signature, expecting 0x00000000")
-    return read_32(fobj, (start + 4, length - 4), size)
-
-
-def read_32(fobj, start_length, size):
-    """
-    Read a 32bit RGB icon resource.  Seems to be either uncompressed or
-    an RLE packbits-like scheme.
-    """
-    (start, length) = start_length
-    fobj.seek(start)
-    pixel_size = (size[0] * size[2], size[1] * size[2])
-    sizesq = pixel_size[0] * pixel_size[1]
-    if length == sizesq * 3:
-        # uncompressed ("RGBRGBGB")
-        indata = fobj.read(length)
-        im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
-    else:
-        # decode image
-        im = Image.new("RGB", pixel_size, None)
-        for band_ix in range(3):
-            data = []
-            bytesleft = sizesq
-            while bytesleft > 0:
-                byte = fobj.read(1)
-                if not byte:
-                    break
-                byte = byte[0]
-                if byte & 0x80:
-                    blocksize = byte - 125
-                    byte = fobj.read(1)
-                    for i in range(blocksize):
-                        data.append(byte)
-                else:
-                    blocksize = byte + 1
-                    data.append(fobj.read(blocksize))
-                bytesleft -= blocksize
-                if bytesleft <= 0:
-                    break
-            if bytesleft != 0:
-                raise SyntaxError(f"Error reading channel [{repr(bytesleft)} left]")
-            band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
-            im.im.putband(band.im, band_ix)
-    return {"RGB": im}
-
-
-def read_mk(fobj, start_length, size):
-    # Alpha masks seem to be uncompressed
-    start = start_length[0]
-    fobj.seek(start)
-    pixel_size = (size[0] * size[2], size[1] * size[2])
-    sizesq = pixel_size[0] * pixel_size[1]
-    band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
-    return {"A": band}
-
-
-def read_png_or_jpeg2000(fobj, start_length, size):
-    (start, length) = start_length
-    fobj.seek(start)
-    sig = fobj.read(12)
-    if sig[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
-        fobj.seek(start)
-        im = PngImagePlugin.PngImageFile(fobj)
-        Image._decompression_bomb_check(im.size)
-        return {"RGBA": im}
-    elif (
-        sig[:4] == b"\xff\x4f\xff\x51"
-        or sig[:4] == b"\x0d\x0a\x87\x0a"
-        or sig == b"\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a"
-    ):
-        if not enable_jpeg2k:
-            raise ValueError(
-                "Unsupported icon subimage format (rebuild PIL "
-                "with JPEG 2000 support to fix this)"
-            )
-        # j2k, jpc or j2c
-        fobj.seek(start)
-        jp2kstream = fobj.read(length)
-        f = io.BytesIO(jp2kstream)
-        im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
-        Image._decompression_bomb_check(im.size)
-        if im.mode != "RGBA":
-            im = im.convert("RGBA")
-        return {"RGBA": im}
-    else:
-        raise ValueError("Unsupported icon subimage format")
-
-
-class IcnsFile:
-
-    SIZES = {
-        (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
-        (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
-        (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
-        (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
-        (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
-        (128, 128, 1): [
-            (b"ic07", read_png_or_jpeg2000),
-            (b"it32", read_32t),
-            (b"t8mk", read_mk),
-        ],
-        (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
-        (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
-        (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
-        (32, 32, 1): [
-            (b"icp5", read_png_or_jpeg2000),
-            (b"il32", read_32),
-            (b"l8mk", read_mk),
-        ],
-        (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
-        (16, 16, 1): [
-            (b"icp4", read_png_or_jpeg2000),
-            (b"is32", read_32),
-            (b"s8mk", read_mk),
-        ],
-    }
-
-    def __init__(self, fobj):
-        """
-        fobj is a file-like object as an icns resource
-        """
-        # signature : (start, length)
-        self.dct = dct = {}
-        self.fobj = fobj
-        sig, filesize = nextheader(fobj)
-        if not _accept(sig):
-            raise SyntaxError("not an icns file")
-        i = HEADERSIZE
-        while i < filesize:
-            sig, blocksize = nextheader(fobj)
-            if blocksize <= 0:
-                raise SyntaxError("invalid block header")
-            i += HEADERSIZE
-            blocksize -= HEADERSIZE
-            dct[sig] = (i, blocksize)
-            fobj.seek(blocksize, io.SEEK_CUR)
-            i += blocksize
-
-    def itersizes(self):
-        sizes = []
-        for size, fmts in self.SIZES.items():
-            for (fmt, reader) in fmts:
-                if fmt in self.dct:
-                    sizes.append(size)
-                    break
-        return sizes
-
-    def bestsize(self):
-        sizes = self.itersizes()
-        if not sizes:
-            raise SyntaxError("No 32bit icon resources found")
-        return max(sizes)
-
-    def dataforsize(self, size):
-        """
-        Get an icon resource as {channel: array}.  Note that
-        the arrays are bottom-up like windows bitmaps and will likely
-        need to be flipped or transposed in some way.
-        """
-        dct = {}
-        for code, reader in self.SIZES[size]:
-            desc = self.dct.get(code)
-            if desc is not None:
-                dct.update(reader(self.fobj, desc, size))
-        return dct
-
-    def getimage(self, size=None):
-        if size is None:
-            size = self.bestsize()
-        if len(size) == 2:
-            size = (size[0], size[1], 1)
-        channels = self.dataforsize(size)
-
-        im = channels.get("RGBA", None)
-        if im:
-            return im
-
-        im = channels.get("RGB").copy()
-        try:
-            im.putalpha(channels["A"])
-        except KeyError:
-            pass
-        return im
-
-
-##
-# Image plugin for Mac OS icons.
-
-
-class IcnsImageFile(ImageFile.ImageFile):
-    """
-    PIL image support for Mac OS .icns files.
-    Chooses the best resolution, but will possibly load
-    a different size image if you mutate the size attribute
-    before calling 'load'.
-
-    The info dictionary has a key 'sizes' that is a list
-    of sizes that the icns file has.
-    """
-
-    format = "ICNS"
-    format_description = "Mac OS icns resource"
-
-    def _open(self):
-        self.icns = IcnsFile(self.fp)
-        self.mode = "RGBA"
-        self.info["sizes"] = self.icns.itersizes()
-        self.best_size = self.icns.bestsize()
-        self.size = (
-            self.best_size[0] * self.best_size[2],
-            self.best_size[1] * self.best_size[2],
-        )
-
-    @property
-    def size(self):
-        return self._size
-
-    @size.setter
-    def size(self, value):
-        info_size = value
-        if info_size not in self.info["sizes"] and len(info_size) == 2:
-            info_size = (info_size[0], info_size[1], 1)
-        if (
-            info_size not in self.info["sizes"]
-            and len(info_size) == 3
-            and info_size[2] == 1
-        ):
-            simple_sizes = [
-                (size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
-            ]
-            if value in simple_sizes:
-                info_size = self.info["sizes"][simple_sizes.index(value)]
-        if info_size not in self.info["sizes"]:
-            raise ValueError("This is not one of the allowed sizes of this image")
-        self._size = value
-
-    def load(self):
-        if len(self.size) == 3:
-            self.best_size = self.size
-            self.size = (
-                self.best_size[0] * self.best_size[2],
-                self.best_size[1] * self.best_size[2],
-            )
-
-        px = Image.Image.load(self)
-        if self.im is not None and self.im.size == self.size:
-            # Already loaded
-            return px
-        self.load_prepare()
-        # This is likely NOT the best way to do it, but whatever.
-        im = self.icns.getimage(self.best_size)
-
-        # If this is a PNG or JPEG 2000, it won't be loaded yet
-        px = im.load()
-
-        self.im = im.im
-        self.mode = im.mode
-        self.size = im.size
-
-        return px
-
-
-def _save(im, fp, filename):
-    """
-    Saves the image as a series of PNG files,
-    that are then combined into a .icns file.
-    """
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-    sizes = {
-        b"ic07": 128,
-        b"ic08": 256,
-        b"ic09": 512,
-        b"ic10": 1024,
-        b"ic11": 32,
-        b"ic12": 64,
-        b"ic13": 256,
-        b"ic14": 512,
-    }
-    provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
-    size_streams = {}
-    for size in set(sizes.values()):
-        image = (
-            provided_images[size]
-            if size in provided_images
-            else im.resize((size, size))
-        )
-
-        temp = io.BytesIO()
-        image.save(temp, "png")
-        size_streams[size] = temp.getvalue()
-
-    entries = []
-    for type, size in sizes.items():
-        stream = size_streams[size]
-        entries.append(
-            {"type": type, "size": HEADERSIZE + len(stream), "stream": stream}
-        )
-
-    # Header
-    fp.write(MAGIC)
-    file_length = HEADERSIZE  # Header
-    file_length += HEADERSIZE + 8 * len(entries)  # TOC
-    file_length += sum(entry["size"] for entry in entries)
-    fp.write(struct.pack(">i", file_length))
-
-    # TOC
-    fp.write(b"TOC ")
-    fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
-    for entry in entries:
-        fp.write(entry["type"])
-        fp.write(struct.pack(">i", entry["size"]))
-
-    # Data
-    for entry in entries:
-        fp.write(entry["type"])
-        fp.write(struct.pack(">i", entry["size"]))
-        fp.write(entry["stream"])
-
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-
-def _accept(prefix):
-    return prefix[:4] == MAGIC
-
-
-Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
-Image.register_extension(IcnsImageFile.format, ".icns")
-
-Image.register_save(IcnsImageFile.format, _save)
-Image.register_mime(IcnsImageFile.format, "image/icns")
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Syntax: python3 IcnsImagePlugin.py [file]")
-        sys.exit()
-
-    with open(sys.argv[1], "rb") as fp:
-        imf = IcnsImageFile(fp)
-        for size in imf.info["sizes"]:
-            imf.size = size
-            imf.save("out-%s-%s-%s.png" % size)
-        with Image.open(sys.argv[1]) as im:
-            im.save("out.png")
-        if sys.platform == "windows":
-            os.startfile("out.png")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/IcoImagePlugin.py

@@ -1,355 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# Windows Icon support for PIL
-#
-# History:
-#       96-05-27 fl     Created
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-
-# This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
-# <casadebender@gmail.com>.
-# https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
-#
-# Icon format references:
-#   * https://en.wikipedia.org/wiki/ICO_(file_format)
-#   * https://msdn.microsoft.com/en-us/library/ms997538.aspx
-
-
-import warnings
-from io import BytesIO
-from math import ceil, log
-
-from . import BmpImagePlugin, Image, ImageFile, PngImagePlugin
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-from ._binary import o8
-from ._binary import o16le as o16
-from ._binary import o32le as o32
-
-#
-# --------------------------------------------------------------------
-
-_MAGIC = b"\0\0\1\0"
-
-
-def _save(im, fp, filename):
-    fp.write(_MAGIC)  # (2+2)
-    bmp = im.encoderinfo.get("bitmap_format") == "bmp"
-    sizes = im.encoderinfo.get(
-        "sizes",
-        [(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)],
-    )
-    frames = []
-    provided_ims = [im] + im.encoderinfo.get("append_images", [])
-    width, height = im.size
-    for size in sorted(set(sizes)):
-        if size[0] > width or size[1] > height or size[0] > 256 or size[1] > 256:
-            continue
-
-        for provided_im in provided_ims:
-            if provided_im.size != size:
-                continue
-            frames.append(provided_im)
-            if bmp:
-                bits = BmpImagePlugin.SAVE[provided_im.mode][1]
-                bits_used = [bits]
-                for other_im in provided_ims:
-                    if other_im.size != size:
-                        continue
-                    bits = BmpImagePlugin.SAVE[other_im.mode][1]
-                    if bits not in bits_used:
-                        # Another image has been supplied for this size
-                        # with a different bit depth
-                        frames.append(other_im)
-                        bits_used.append(bits)
-            break
-        else:
-            # TODO: invent a more convenient method for proportional scalings
-            frame = provided_im.copy()
-            frame.thumbnail(size, Image.Resampling.LANCZOS, reducing_gap=None)
-            frames.append(frame)
-    fp.write(o16(len(frames)))  # idCount(2)
-    offset = fp.tell() + len(frames) * 16
-    for frame in frames:
-        width, height = frame.size
-        # 0 means 256
-        fp.write(o8(width if width < 256 else 0))  # bWidth(1)
-        fp.write(o8(height if height < 256 else 0))  # bHeight(1)
-
-        bits, colors = BmpImagePlugin.SAVE[frame.mode][1:] if bmp else (32, 0)
-        fp.write(o8(colors))  # bColorCount(1)
-        fp.write(b"\0")  # bReserved(1)
-        fp.write(b"\0\0")  # wPlanes(2)
-        fp.write(o16(bits))  # wBitCount(2)
-
-        image_io = BytesIO()
-        if bmp:
-            frame.save(image_io, "dib")
-
-            if bits != 32:
-                and_mask = Image.new("1", size)
-                ImageFile._save(
-                    and_mask, image_io, [("raw", (0, 0) + size, 0, ("1", 0, -1))]
-                )
-        else:
-            frame.save(image_io, "png")
-        image_io.seek(0)
-        image_bytes = image_io.read()
-        if bmp:
-            image_bytes = image_bytes[:8] + o32(height * 2) + image_bytes[12:]
-        bytes_len = len(image_bytes)
-        fp.write(o32(bytes_len))  # dwBytesInRes(4)
-        fp.write(o32(offset))  # dwImageOffset(4)
-        current = fp.tell()
-        fp.seek(offset)
-        fp.write(image_bytes)
-        offset = offset + bytes_len
-        fp.seek(current)
-
-
-def _accept(prefix):
-    return prefix[:4] == _MAGIC
-
-
-class IcoFile:
-    def __init__(self, buf):
-        """
-        Parse image from file-like object containing ico file data
-        """
-
-        # check magic
-        s = buf.read(6)
-        if not _accept(s):
-            raise SyntaxError("not an ICO file")
-
-        self.buf = buf
-        self.entry = []
-
-        # Number of items in file
-        self.nb_items = i16(s, 4)
-
-        # Get headers for each item
-        for i in range(self.nb_items):
-            s = buf.read(16)
-
-            icon_header = {
-                "width": s[0],
-                "height": s[1],
-                "nb_color": s[2],  # No. of colors in image (0 if >=8bpp)
-                "reserved": s[3],
-                "planes": i16(s, 4),
-                "bpp": i16(s, 6),
-                "size": i32(s, 8),
-                "offset": i32(s, 12),
-            }
-
-            # See Wikipedia
-            for j in ("width", "height"):
-                if not icon_header[j]:
-                    icon_header[j] = 256
-
-            # See Wikipedia notes about color depth.
-            # We need this just to differ images with equal sizes
-            icon_header["color_depth"] = (
-                icon_header["bpp"]
-                or (
-                    icon_header["nb_color"] != 0
-                    and ceil(log(icon_header["nb_color"], 2))
-                )
-                or 256
-            )
-
-            icon_header["dim"] = (icon_header["width"], icon_header["height"])
-            icon_header["square"] = icon_header["width"] * icon_header["height"]
-
-            self.entry.append(icon_header)
-
-        self.entry = sorted(self.entry, key=lambda x: x["color_depth"])
-        # ICO images are usually squares
-        # self.entry = sorted(self.entry, key=lambda x: x['width'])
-        self.entry = sorted(self.entry, key=lambda x: x["square"])
-        self.entry.reverse()
-
-    def sizes(self):
-        """
-        Get a list of all available icon sizes and color depths.
-        """
-        return {(h["width"], h["height"]) for h in self.entry}
-
-    def getentryindex(self, size, bpp=False):
-        for (i, h) in enumerate(self.entry):
-            if size == h["dim"] and (bpp is False or bpp == h["color_depth"]):
-                return i
-        return 0
-
-    def getimage(self, size, bpp=False):
-        """
-        Get an image from the icon
-        """
-        return self.frame(self.getentryindex(size, bpp))
-
-    def frame(self, idx):
-        """
-        Get an image from frame idx
-        """
-
-        header = self.entry[idx]
-
-        self.buf.seek(header["offset"])
-        data = self.buf.read(8)
-        self.buf.seek(header["offset"])
-
-        if data[:8] == PngImagePlugin._MAGIC:
-            # png frame
-            im = PngImagePlugin.PngImageFile(self.buf)
-            Image._decompression_bomb_check(im.size)
-        else:
-            # XOR + AND mask bmp frame
-            im = BmpImagePlugin.DibImageFile(self.buf)
-            Image._decompression_bomb_check(im.size)
-
-            # change tile dimension to only encompass XOR image
-            im._size = (im.size[0], int(im.size[1] / 2))
-            d, e, o, a = im.tile[0]
-            im.tile[0] = d, (0, 0) + im.size, o, a
-
-            # figure out where AND mask image starts
-            bpp = header["bpp"]
-            if 32 == bpp:
-                # 32-bit color depth icon image allows semitransparent areas
-                # PIL's DIB format ignores transparency bits, recover them.
-                # The DIB is packed in BGRX byte order where X is the alpha
-                # channel.
-
-                # Back up to start of bmp data
-                self.buf.seek(o)
-                # extract every 4th byte (eg. 3,7,11,15,...)
-                alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
-
-                # convert to an 8bpp grayscale image
-                mask = Image.frombuffer(
-                    "L",  # 8bpp
-                    im.size,  # (w, h)
-                    alpha_bytes,  # source chars
-                    "raw",  # raw decoder
-                    ("L", 0, -1),  # 8bpp inverted, unpadded, reversed
-                )
-            else:
-                # get AND image from end of bitmap
-                w = im.size[0]
-                if (w % 32) > 0:
-                    # bitmap row data is aligned to word boundaries
-                    w += 32 - (im.size[0] % 32)
-
-                # the total mask data is
-                # padded row size * height / bits per char
-
-                total_bytes = int((w * im.size[1]) / 8)
-                and_mask_offset = header["offset"] + header["size"] - total_bytes
-
-                self.buf.seek(and_mask_offset)
-                mask_data = self.buf.read(total_bytes)
-
-                # convert raw data to image
-                mask = Image.frombuffer(
-                    "1",  # 1 bpp
-                    im.size,  # (w, h)
-                    mask_data,  # source chars
-                    "raw",  # raw decoder
-                    ("1;I", int(w / 8), -1),  # 1bpp inverted, padded, reversed
-                )
-
-                # now we have two images, im is XOR image and mask is AND image
-
-            # apply mask image as alpha channel
-            im = im.convert("RGBA")
-            im.putalpha(mask)
-
-        return im
-
-
-##
-# Image plugin for Windows Icon files.
-
-
-class IcoImageFile(ImageFile.ImageFile):
-    """
-    PIL read-only image support for Microsoft Windows .ico files.
-
-    By default the largest resolution image in the file will be loaded. This
-    can be changed by altering the 'size' attribute before calling 'load'.
-
-    The info dictionary has a key 'sizes' that is a list of the sizes available
-    in the icon file.
-
-    Handles classic, XP and Vista icon formats.
-
-    When saving, PNG compression is used. Support for this was only added in
-    Windows Vista. If you are unable to view the icon in Windows, convert the
-    image to "RGBA" mode before saving.
-
-    This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
-    <casadebender@gmail.com>.
-    https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
-    """
-
-    format = "ICO"
-    format_description = "Windows Icon"
-
-    def _open(self):
-        self.ico = IcoFile(self.fp)
-        self.info["sizes"] = self.ico.sizes()
-        self.size = self.ico.entry[0]["dim"]
-        self.load()
-
-    @property
-    def size(self):
-        return self._size
-
-    @size.setter
-    def size(self, value):
-        if value not in self.info["sizes"]:
-            raise ValueError("This is not one of the allowed sizes of this image")
-        self._size = value
-
-    def load(self):
-        if self.im is not None and self.im.size == self.size:
-            # Already loaded
-            return Image.Image.load(self)
-        im = self.ico.getimage(self.size)
-        # if tile is PNG, it won't really be loaded yet
-        im.load()
-        self.im = im.im
-        self.mode = im.mode
-        if im.size != self.size:
-            warnings.warn("Image was not the expected size")
-
-            index = self.ico.getentryindex(self.size)
-            sizes = list(self.info["sizes"])
-            sizes[index] = im.size
-            self.info["sizes"] = set(sizes)
-
-            self.size = im.size
-
-    def load_seek(self):
-        # Flag the ImageFile.Parser so that it
-        # just does all the decode at the end.
-        pass
-
-
-#
-# --------------------------------------------------------------------
-
-
-Image.register_open(IcoImageFile.format, IcoImageFile, _accept)
-Image.register_save(IcoImageFile.format, _save)
-Image.register_extension(IcoImageFile.format, ".ico")
-
-Image.register_mime(IcoImageFile.format, "image/x-icon")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImImagePlugin.py

@@ -1,373 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# IFUNC IM file handling for PIL
-#
-# history:
-# 1995-09-01 fl   Created.
-# 1997-01-03 fl   Save palette images
-# 1997-01-08 fl   Added sequence support
-# 1997-01-23 fl   Added P and RGB save support
-# 1997-05-31 fl   Read floating point images
-# 1997-06-22 fl   Save floating point images
-# 1997-08-27 fl   Read and save 1-bit images
-# 1998-06-25 fl   Added support for RGB+LUT images
-# 1998-07-02 fl   Added support for YCC images
-# 1998-07-15 fl   Renamed offset attribute to avoid name clash
-# 1998-12-29 fl   Added I;16 support
-# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.7)
-# 2003-09-26 fl   Added LA/PA support
-#
-# Copyright (c) 1997-2003 by Secret Labs AB.
-# Copyright (c) 1995-2001 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-import os
-import re
-
-from . import Image, ImageFile, ImagePalette
-
-# --------------------------------------------------------------------
-# Standard tags
-
-COMMENT = "Comment"
-DATE = "Date"
-EQUIPMENT = "Digitalization equipment"
-FRAMES = "File size (no of images)"
-LUT = "Lut"
-NAME = "Name"
-SCALE = "Scale (x,y)"
-SIZE = "Image size (x*y)"
-MODE = "Image type"
-
-TAGS = {
-    COMMENT: 0,
-    DATE: 0,
-    EQUIPMENT: 0,
-    FRAMES: 0,
-    LUT: 0,
-    NAME: 0,
-    SCALE: 0,
-    SIZE: 0,
-    MODE: 0,
-}
-
-OPEN = {
-    # ifunc93/p3cfunc formats
-    "0 1 image": ("1", "1"),
-    "L 1 image": ("1", "1"),
-    "Greyscale image": ("L", "L"),
-    "Grayscale image": ("L", "L"),
-    "RGB image": ("RGB", "RGB;L"),
-    "RLB image": ("RGB", "RLB"),
-    "RYB image": ("RGB", "RLB"),
-    "B1 image": ("1", "1"),
-    "B2 image": ("P", "P;2"),
-    "B4 image": ("P", "P;4"),
-    "X 24 image": ("RGB", "RGB"),
-    "L 32 S image": ("I", "I;32"),
-    "L 32 F image": ("F", "F;32"),
-    # old p3cfunc formats
-    "RGB3 image": ("RGB", "RGB;T"),
-    "RYB3 image": ("RGB", "RYB;T"),
-    # extensions
-    "LA image": ("LA", "LA;L"),
-    "PA image": ("LA", "PA;L"),
-    "RGBA image": ("RGBA", "RGBA;L"),
-    "RGBX image": ("RGBX", "RGBX;L"),
-    "CMYK image": ("CMYK", "CMYK;L"),
-    "YCC image": ("YCbCr", "YCbCr;L"),
-}
-
-# ifunc95 extensions
-for i in ["8", "8S", "16", "16S", "32", "32F"]:
-    OPEN[f"L {i} image"] = ("F", f"F;{i}")
-    OPEN[f"L*{i} image"] = ("F", f"F;{i}")
-for i in ["16", "16L", "16B"]:
-    OPEN[f"L {i} image"] = (f"I;{i}", f"I;{i}")
-    OPEN[f"L*{i} image"] = (f"I;{i}", f"I;{i}")
-for i in ["32S"]:
-    OPEN[f"L {i} image"] = ("I", f"I;{i}")
-    OPEN[f"L*{i} image"] = ("I", f"I;{i}")
-for i in range(2, 33):
-    OPEN[f"L*{i} image"] = ("F", f"F;{i}")
-
-
-# --------------------------------------------------------------------
-# Read IM directory
-
-split = re.compile(rb"^([A-Za-z][^:]*):[ \t]*(.*)[ \t]*$")
-
-
-def number(s):
-    try:
-        return int(s)
-    except ValueError:
-        return float(s)
-
-
-##
-# Image plugin for the IFUNC IM file format.
-
-
-class ImImageFile(ImageFile.ImageFile):
-
-    format = "IM"
-    format_description = "IFUNC Image Memory"
-    _close_exclusive_fp_after_loading = False
-
-    def _open(self):
-
-        # Quick rejection: if there's not an LF among the first
-        # 100 bytes, this is (probably) not a text header.
-
-        if b"\n" not in self.fp.read(100):
-            raise SyntaxError("not an IM file")
-        self.fp.seek(0)
-
-        n = 0
-
-        # Default values
-        self.info[MODE] = "L"
-        self.info[SIZE] = (512, 512)
-        self.info[FRAMES] = 1
-
-        self.rawmode = "L"
-
-        while True:
-
-            s = self.fp.read(1)
-
-            # Some versions of IFUNC uses \n\r instead of \r\n...
-            if s == b"\r":
-                continue
-
-            if not s or s == b"\0" or s == b"\x1A":
-                break
-
-            # FIXME: this may read whole file if not a text file
-            s = s + self.fp.readline()
-
-            if len(s) > 100:
-                raise SyntaxError("not an IM file")
-
-            if s[-2:] == b"\r\n":
-                s = s[:-2]
-            elif s[-1:] == b"\n":
-                s = s[:-1]
-
-            try:
-                m = split.match(s)
-            except re.error as e:
-                raise SyntaxError("not an IM file") from e
-
-            if m:
-
-                k, v = m.group(1, 2)
-
-                # Don't know if this is the correct encoding,
-                # but a decent guess (I guess)
-                k = k.decode("latin-1", "replace")
-                v = v.decode("latin-1", "replace")
-
-                # Convert value as appropriate
-                if k in [FRAMES, SCALE, SIZE]:
-                    v = v.replace("*", ",")
-                    v = tuple(map(number, v.split(",")))
-                    if len(v) == 1:
-                        v = v[0]
-                elif k == MODE and v in OPEN:
-                    v, self.rawmode = OPEN[v]
-
-                # Add to dictionary. Note that COMMENT tags are
-                # combined into a list of strings.
-                if k == COMMENT:
-                    if k in self.info:
-                        self.info[k].append(v)
-                    else:
-                        self.info[k] = [v]
-                else:
-                    self.info[k] = v
-
-                if k in TAGS:
-                    n += 1
-
-            else:
-
-                raise SyntaxError(
-                    "Syntax error in IM header: " + s.decode("ascii", "replace")
-                )
-
-        if not n:
-            raise SyntaxError("Not an IM file")
-
-        # Basic attributes
-        self._size = self.info[SIZE]
-        self.mode = self.info[MODE]
-
-        # Skip forward to start of image data
-        while s and s[:1] != b"\x1A":
-            s = self.fp.read(1)
-        if not s:
-            raise SyntaxError("File truncated")
-
-        if LUT in self.info:
-            # convert lookup table to palette or lut attribute
-            palette = self.fp.read(768)
-            greyscale = 1  # greyscale palette
-            linear = 1  # linear greyscale palette
-            for i in range(256):
-                if palette[i] == palette[i + 256] == palette[i + 512]:
-                    if palette[i] != i:
-                        linear = 0
-                else:
-                    greyscale = 0
-            if self.mode in ["L", "LA", "P", "PA"]:
-                if greyscale:
-                    if not linear:
-                        self.lut = list(palette[:256])
-                else:
-                    if self.mode in ["L", "P"]:
-                        self.mode = self.rawmode = "P"
-                    elif self.mode in ["LA", "PA"]:
-                        self.mode = "PA"
-                        self.rawmode = "PA;L"
-                    self.palette = ImagePalette.raw("RGB;L", palette)
-            elif self.mode == "RGB":
-                if not greyscale or not linear:
-                    self.lut = list(palette)
-
-        self.frame = 0
-
-        self.__offset = offs = self.fp.tell()
-
-        self._fp = self.fp  # FIXME: hack
-
-        if self.rawmode[:2] == "F;":
-
-            # ifunc95 formats
-            try:
-                # use bit decoder (if necessary)
-                bits = int(self.rawmode[2:])
-                if bits not in [8, 16, 32]:
-                    self.tile = [("bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1))]
-                    return
-            except ValueError:
-                pass
-
-        if self.rawmode in ["RGB;T", "RYB;T"]:
-            # Old LabEye/3PC files.  Would be very surprised if anyone
-            # ever stumbled upon such a file ;-)
-            size = self.size[0] * self.size[1]
-            self.tile = [
-                ("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
-                ("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
-                ("raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)),
-            ]
-        else:
-            # LabEye/IFUNC files
-            self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
-
-    @property
-    def n_frames(self):
-        return self.info[FRAMES]
-
-    @property
-    def is_animated(self):
-        return self.info[FRAMES] > 1
-
-    def seek(self, frame):
-        if not self._seek_check(frame):
-            return
-
-        self.frame = frame
-
-        if self.mode == "1":
-            bits = 1
-        else:
-            bits = 8 * len(self.mode)
-
-        size = ((self.size[0] * bits + 7) // 8) * self.size[1]
-        offs = self.__offset + frame * size
-
-        self.fp = self._fp
-
-        self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
-
-    def tell(self):
-        return self.frame
-
-
-#
-# --------------------------------------------------------------------
-# Save IM files
-
-
-SAVE = {
-    # mode: (im type, raw mode)
-    "1": ("0 1", "1"),
-    "L": ("Greyscale", "L"),
-    "LA": ("LA", "LA;L"),
-    "P": ("Greyscale", "P"),
-    "PA": ("LA", "PA;L"),
-    "I": ("L 32S", "I;32S"),
-    "I;16": ("L 16", "I;16"),
-    "I;16L": ("L 16L", "I;16L"),
-    "I;16B": ("L 16B", "I;16B"),
-    "F": ("L 32F", "F;32F"),
-    "RGB": ("RGB", "RGB;L"),
-    "RGBA": ("RGBA", "RGBA;L"),
-    "RGBX": ("RGBX", "RGBX;L"),
-    "CMYK": ("CMYK", "CMYK;L"),
-    "YCbCr": ("YCC", "YCbCr;L"),
-}
-
-
-def _save(im, fp, filename):
-
-    try:
-        image_type, rawmode = SAVE[im.mode]
-    except KeyError as e:
-        raise ValueError(f"Cannot save {im.mode} images as IM") from e
-
-    frames = im.encoderinfo.get("frames", 1)
-
-    fp.write(f"Image type: {image_type} image\r\n".encode("ascii"))
-    if filename:
-        # Each line must be 100 characters or less,
-        # or: SyntaxError("not an IM file")
-        # 8 characters are used for "Name: " and "\r\n"
-        # Keep just the filename, ditch the potentially overlong path
-        name, ext = os.path.splitext(os.path.basename(filename))
-        name = "".join([name[: 92 - len(ext)], ext])
-
-        fp.write(f"Name: {name}\r\n".encode("ascii"))
-    fp.write(("Image size (x*y): %d*%d\r\n" % im.size).encode("ascii"))
-    fp.write(f"File size (no of images): {frames}\r\n".encode("ascii"))
-    if im.mode in ["P", "PA"]:
-        fp.write(b"Lut: 1\r\n")
-    fp.write(b"\000" * (511 - fp.tell()) + b"\032")
-    if im.mode in ["P", "PA"]:
-        im_palette = im.im.getpalette("RGB", "RGB;L")
-        colors = len(im_palette) // 3
-        palette = b""
-        for i in range(3):
-            palette += im_palette[colors * i : colors * (i + 1)]
-            palette += b"\x00" * (256 - colors)
-        fp.write(palette)  # 768 bytes
-    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))])
-
-
-#
-# --------------------------------------------------------------------
-# Registry
-
-
-Image.register_open(ImImageFile.format, ImImageFile)
-Image.register_save(ImImageFile.format, _save)
-
-Image.register_extension(ImImageFile.format, ".im")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageChops.py

@@ -1,329 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# standard channel operations
-#
-# History:
-# 1996-03-24 fl   Created
-# 1996-08-13 fl   Added logical operations (for "1" images)
-# 2000-10-12 fl   Added offset method (from Image.py)
-#
-# Copyright (c) 1997-2000 by Secret Labs AB
-# Copyright (c) 1996-2000 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image
-
-
-def constant(image, value):
-    """Fill a channel with a given grey level.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.new("L", image.size, value)
-
-
-def duplicate(image):
-    """Copy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return image.copy()
-
-
-def invert(image):
-    """
-    Invert an image (channel).
-
-    .. code-block:: python
-
-        out = MAX - image
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image.load()
-    return image._new(image.im.chop_invert())
-
-
-def lighter(image1, image2):
-    """
-    Compares the two images, pixel by pixel, and returns a new image containing
-    the lighter values.
-
-    .. code-block:: python
-
-        out = max(image1, image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_lighter(image2.im))
-
-
-def darker(image1, image2):
-    """
-    Compares the two images, pixel by pixel, and returns a new image containing
-    the darker values.
-
-    .. code-block:: python
-
-        out = min(image1, image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_darker(image2.im))
-
-
-def difference(image1, image2):
-    """
-    Returns the absolute value of the pixel-by-pixel difference between the two
-    images.
-
-    .. code-block:: python
-
-        out = abs(image1 - image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_difference(image2.im))
-
-
-def multiply(image1, image2):
-    """
-    Superimposes two images on top of each other.
-
-    If you multiply an image with a solid black image, the result is black. If
-    you multiply with a solid white image, the image is unaffected.
-
-    .. code-block:: python
-
-        out = image1 * image2 / MAX
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_multiply(image2.im))
-
-
-def screen(image1, image2):
-    """
-    Superimposes two inverted images on top of each other.
-
-    .. code-block:: python
-
-        out = MAX - ((MAX - image1) * (MAX - image2) / MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_screen(image2.im))
-
-
-def soft_light(image1, image2):
-    """
-    Superimposes two images on top of each other using the Soft Light algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_soft_light(image2.im))
-
-
-def hard_light(image1, image2):
-    """
-    Superimposes two images on top of each other using the Hard Light algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_hard_light(image2.im))
-
-
-def overlay(image1, image2):
-    """
-    Superimposes two images on top of each other using the Overlay algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_overlay(image2.im))
-
-
-def add(image1, image2, scale=1.0, offset=0):
-    """
-    Adds two images, dividing the result by scale and adding the
-    offset. If omitted, scale defaults to 1.0, and offset to 0.0.
-
-    .. code-block:: python
-
-        out = ((image1 + image2) / scale + offset)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_add(image2.im, scale, offset))
-
-
-def subtract(image1, image2, scale=1.0, offset=0):
-    """
-    Subtracts two images, dividing the result by scale and adding the offset.
-    If omitted, scale defaults to 1.0, and offset to 0.0.
-
-    .. code-block:: python
-
-        out = ((image1 - image2) / scale + offset)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_subtract(image2.im, scale, offset))
-
-
-def add_modulo(image1, image2):
-    """Add two images, without clipping the result.
-
-    .. code-block:: python
-
-        out = ((image1 + image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_add_modulo(image2.im))
-
-
-def subtract_modulo(image1, image2):
-    """Subtract two images, without clipping the result.
-
-    .. code-block:: python
-
-        out = ((image1 - image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_subtract_modulo(image2.im))
-
-
-def logical_and(image1, image2):
-    """Logical AND between two images.
-
-    Both of the images must have mode "1". If you would like to perform a
-    logical AND on an image with a mode other than "1", try
-    :py:meth:`~PIL.ImageChops.multiply` instead, using a black-and-white mask
-    as the second image.
-
-    .. code-block:: python
-
-        out = ((image1 and image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_and(image2.im))
-
-
-def logical_or(image1, image2):
-    """Logical OR between two images.
-
-    Both of the images must have mode "1".
-
-    .. code-block:: python
-
-        out = ((image1 or image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_or(image2.im))
-
-
-def logical_xor(image1, image2):
-    """Logical XOR between two images.
-
-    Both of the images must have mode "1".
-
-    .. code-block:: python
-
-        out = ((bool(image1) != bool(image2)) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_xor(image2.im))
-
-
-def blend(image1, image2, alpha):
-    """Blend images using constant transparency weight. Alias for
-    :py:func:`PIL.Image.blend`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.blend(image1, image2, alpha)
-
-
-def composite(image1, image2, mask):
-    """Create composite using transparency mask. Alias for
-    :py:func:`PIL.Image.composite`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.composite(image1, image2, mask)
-
-
-def offset(image, xoffset, yoffset=None):
-    """Returns a copy of the image where data has been offset by the given
-    distances. Data wraps around the edges. If ``yoffset`` is omitted, it
-    is assumed to be equal to ``xoffset``.
-
-    :param image: Input image.
-    :param xoffset: The horizontal distance.
-    :param yoffset: The vertical distance.  If omitted, both
-        distances are set to the same value.
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    if yoffset is None:
-        yoffset = xoffset
-    image.load()
-    return image._new(image.im.offset(xoffset, yoffset))

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageColor.py

@@ -1,303 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# map CSS3-style colour description strings to RGB
-#
-# History:
-# 2002-10-24 fl   Added support for CSS-style color strings
-# 2002-12-15 fl   Added RGBA support
-# 2004-03-27 fl   Fixed remaining int() problems for Python 1.5.2
-# 2004-07-19 fl   Fixed gray/grey spelling issues
-# 2009-03-05 fl   Fixed rounding error in grayscale calculation
-#
-# Copyright (c) 2002-2004 by Secret Labs AB
-# Copyright (c) 2002-2004 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import re
-
-from . import Image
-
-
-def getrgb(color):
-    """
-     Convert a color string to an RGB or RGBA tuple. If the string cannot be
-     parsed, this function raises a :py:exc:`ValueError` exception.
-
-    .. versionadded:: 1.1.4
-
-    :param color: A color string
-    :return: ``(red, green, blue[, alpha])``
-    """
-    if len(color) > 100:
-        raise ValueError("color specifier is too long")
-    color = color.lower()
-
-    rgb = colormap.get(color, None)
-    if rgb:
-        if isinstance(rgb, tuple):
-            return rgb
-        colormap[color] = rgb = getrgb(rgb)
-        return rgb
-
-    # check for known string formats
-    if re.match("#[a-f0-9]{3}$", color):
-        return int(color[1] * 2, 16), int(color[2] * 2, 16), int(color[3] * 2, 16)
-
-    if re.match("#[a-f0-9]{4}$", color):
-        return (
-            int(color[1] * 2, 16),
-            int(color[2] * 2, 16),
-            int(color[3] * 2, 16),
-            int(color[4] * 2, 16),
-        )
-
-    if re.match("#[a-f0-9]{6}$", color):
-        return int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
-
-    if re.match("#[a-f0-9]{8}$", color):
-        return (
-            int(color[1:3], 16),
-            int(color[3:5], 16),
-            int(color[5:7], 16),
-            int(color[7:9], 16),
-        )
-
-    m = re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
-    if m:
-        return int(m.group(1)), int(m.group(2)), int(m.group(3))
-
-    m = re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color)
-    if m:
-        return (
-            int((int(m.group(1)) * 255) / 100.0 + 0.5),
-            int((int(m.group(2)) * 255) / 100.0 + 0.5),
-            int((int(m.group(3)) * 255) / 100.0 + 0.5),
-        )
-
-    m = re.match(
-        r"hsl\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
-    )
-    if m:
-        from colorsys import hls_to_rgb
-
-        rgb = hls_to_rgb(
-            float(m.group(1)) / 360.0,
-            float(m.group(3)) / 100.0,
-            float(m.group(2)) / 100.0,
-        )
-        return (
-            int(rgb[0] * 255 + 0.5),
-            int(rgb[1] * 255 + 0.5),
-            int(rgb[2] * 255 + 0.5),
-        )
-
-    m = re.match(
-        r"hs[bv]\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
-    )
-    if m:
-        from colorsys import hsv_to_rgb
-
-        rgb = hsv_to_rgb(
-            float(m.group(1)) / 360.0,
-            float(m.group(2)) / 100.0,
-            float(m.group(3)) / 100.0,
-        )
-        return (
-            int(rgb[0] * 255 + 0.5),
-            int(rgb[1] * 255 + 0.5),
-            int(rgb[2] * 255 + 0.5),
-        )
-
-    m = re.match(r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
-    if m:
-        return int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
-    raise ValueError(f"unknown color specifier: {repr(color)}")
-
-
-def getcolor(color, mode):
-    """
-    Same as :py:func:`~PIL.ImageColor.getrgb`, but converts the RGB value to a
-    greyscale value if ``mode`` is not color or a palette image. If the string
-    cannot be parsed, this function raises a :py:exc:`ValueError` exception.
-
-    .. versionadded:: 1.1.4
-
-    :param color: A color string
-    :param mode: Convert result to this mode
-    :return: ``(graylevel[, alpha]) or (red, green, blue[, alpha])``
-    """
-    # same as getrgb, but converts the result to the given mode
-    color, alpha = getrgb(color), 255
-    if len(color) == 4:
-        color, alpha = color[:3], color[3]
-
-    if Image.getmodebase(mode) == "L":
-        r, g, b = color
-        # ITU-R Recommendation 601-2 for nonlinear RGB
-        # scaled to 24 bits to match the convert's implementation.
-        color = (r * 19595 + g * 38470 + b * 7471 + 0x8000) >> 16
-        if mode[-1] == "A":
-            return color, alpha
-    else:
-        if mode[-1] == "A":
-            return color + (alpha,)
-    return color
-
-
-colormap = {
-    # X11 colour table from https://drafts.csswg.org/css-color-4/, with
-    # gray/grey spelling issues fixed.  This is a superset of HTML 4.0
-    # colour names used in CSS 1.
-    "aliceblue": "#f0f8ff",
-    "antiquewhite": "#faebd7",
-    "aqua": "#00ffff",
-    "aquamarine": "#7fffd4",
-    "azure": "#f0ffff",
-    "beige": "#f5f5dc",
-    "bisque": "#ffe4c4",
-    "black": "#000000",
-    "blanchedalmond": "#ffebcd",
-    "blue": "#0000ff",
-    "blueviolet": "#8a2be2",
-    "brown": "#a52a2a",
-    "burlywood": "#deb887",
-    "cadetblue": "#5f9ea0",
-    "chartreuse": "#7fff00",
-    "chocolate": "#d2691e",
-    "coral": "#ff7f50",
-    "cornflowerblue": "#6495ed",
-    "cornsilk": "#fff8dc",
-    "crimson": "#dc143c",
-    "cyan": "#00ffff",
-    "darkblue": "#00008b",
-    "darkcyan": "#008b8b",
-    "darkgoldenrod": "#b8860b",
-    "darkgray": "#a9a9a9",
-    "darkgrey": "#a9a9a9",
-    "darkgreen": "#006400",
-    "darkkhaki": "#bdb76b",
-    "darkmagenta": "#8b008b",
-    "darkolivegreen": "#556b2f",
-    "darkorange": "#ff8c00",
-    "darkorchid": "#9932cc",
-    "darkred": "#8b0000",
-    "darksalmon": "#e9967a",
-    "darkseagreen": "#8fbc8f",
-    "darkslateblue": "#483d8b",
-    "darkslategray": "#2f4f4f",
-    "darkslategrey": "#2f4f4f",
-    "darkturquoise": "#00ced1",
-    "darkviolet": "#9400d3",
-    "deeppink": "#ff1493",
-    "deepskyblue": "#00bfff",
-    "dimgray": "#696969",
-    "dimgrey": "#696969",
-    "dodgerblue": "#1e90ff",
-    "firebrick": "#b22222",
-    "floralwhite": "#fffaf0",
-    "forestgreen": "#228b22",
-    "fuchsia": "#ff00ff",
-    "gainsboro": "#dcdcdc",
-    "ghostwhite": "#f8f8ff",
-    "gold": "#ffd700",
-    "goldenrod": "#daa520",
-    "gray": "#808080",
-    "grey": "#808080",
-    "green": "#008000",
-    "greenyellow": "#adff2f",
-    "honeydew": "#f0fff0",
-    "hotpink": "#ff69b4",
-    "indianred": "#cd5c5c",
-    "indigo": "#4b0082",
-    "ivory": "#fffff0",
-    "khaki": "#f0e68c",
-    "lavender": "#e6e6fa",
-    "lavenderblush": "#fff0f5",
-    "lawngreen": "#7cfc00",
-    "lemonchiffon": "#fffacd",
-    "lightblue": "#add8e6",
-    "lightcoral": "#f08080",
-    "lightcyan": "#e0ffff",
-    "lightgoldenrodyellow": "#fafad2",
-    "lightgreen": "#90ee90",
-    "lightgray": "#d3d3d3",
-    "lightgrey": "#d3d3d3",
-    "lightpink": "#ffb6c1",
-    "lightsalmon": "#ffa07a",
-    "lightseagreen": "#20b2aa",
-    "lightskyblue": "#87cefa",
-    "lightslategray": "#778899",
-    "lightslategrey": "#778899",
-    "lightsteelblue": "#b0c4de",
-    "lightyellow": "#ffffe0",
-    "lime": "#00ff00",
-    "limegreen": "#32cd32",
-    "linen": "#faf0e6",
-    "magenta": "#ff00ff",
-    "maroon": "#800000",
-    "mediumaquamarine": "#66cdaa",
-    "mediumblue": "#0000cd",
-    "mediumorchid": "#ba55d3",
-    "mediumpurple": "#9370db",
-    "mediumseagreen": "#3cb371",
-    "mediumslateblue": "#7b68ee",
-    "mediumspringgreen": "#00fa9a",
-    "mediumturquoise": "#48d1cc",
-    "mediumvioletred": "#c71585",
-    "midnightblue": "#191970",
-    "mintcream": "#f5fffa",
-    "mistyrose": "#ffe4e1",
-    "moccasin": "#ffe4b5",
-    "navajowhite": "#ffdead",
-    "navy": "#000080",
-    "oldlace": "#fdf5e6",
-    "olive": "#808000",
-    "olivedrab": "#6b8e23",
-    "orange": "#ffa500",
-    "orangered": "#ff4500",
-    "orchid": "#da70d6",
-    "palegoldenrod": "#eee8aa",
-    "palegreen": "#98fb98",
-    "paleturquoise": "#afeeee",
-    "palevioletred": "#db7093",
-    "papayawhip": "#ffefd5",
-    "peachpuff": "#ffdab9",
-    "peru": "#cd853f",
-    "pink": "#ffc0cb",
-    "plum": "#dda0dd",
-    "powderblue": "#b0e0e6",
-    "purple": "#800080",
-    "rebeccapurple": "#663399",
-    "red": "#ff0000",
-    "rosybrown": "#bc8f8f",
-    "royalblue": "#4169e1",
-    "saddlebrown": "#8b4513",
-    "salmon": "#fa8072",
-    "sandybrown": "#f4a460",
-    "seagreen": "#2e8b57",
-    "seashell": "#fff5ee",
-    "sienna": "#a0522d",
-    "silver": "#c0c0c0",
-    "skyblue": "#87ceeb",
-    "slateblue": "#6a5acd",
-    "slategray": "#708090",
-    "slategrey": "#708090",
-    "snow": "#fffafa",
-    "springgreen": "#00ff7f",
-    "steelblue": "#4682b4",
-    "tan": "#d2b48c",
-    "teal": "#008080",
-    "thistle": "#d8bfd8",
-    "tomato": "#ff6347",
-    "turquoise": "#40e0d0",
-    "violet": "#ee82ee",
-    "wheat": "#f5deb3",
-    "white": "#ffffff",
-    "whitesmoke": "#f5f5f5",
-    "yellow": "#ffff00",
-    "yellowgreen": "#9acd32",
-}

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageDraw2.py

@@ -1,209 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# WCK-style drawing interface operations
-#
-# History:
-# 2003-12-07 fl   created
-# 2005-05-15 fl   updated; added to PIL as ImageDraw2
-# 2005-05-15 fl   added text support
-# 2005-05-20 fl   added arc/chord/pieslice support
-#
-# Copyright (c) 2003-2005 by Secret Labs AB
-# Copyright (c) 2003-2005 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-"""
-(Experimental) WCK-style drawing interface operations
-
-.. seealso:: :py:mod:`PIL.ImageDraw`
-"""
-
-
-import warnings
-
-from . import Image, ImageColor, ImageDraw, ImageFont, ImagePath
-from ._deprecate import deprecate
-
-
-class Pen:
-    """Stores an outline color and width."""
-
-    def __init__(self, color, width=1, opacity=255):
-        self.color = ImageColor.getrgb(color)
-        self.width = width
-
-
-class Brush:
-    """Stores a fill color"""
-
-    def __init__(self, color, opacity=255):
-        self.color = ImageColor.getrgb(color)
-
-
-class Font:
-    """Stores a TrueType font and color"""
-
-    def __init__(self, color, file, size=12):
-        # FIXME: add support for bitmap fonts
-        self.color = ImageColor.getrgb(color)
-        self.font = ImageFont.truetype(file, size)
-
-
-class Draw:
-    """
-    (Experimental) WCK-style drawing interface
-    """
-
-    def __init__(self, image, size=None, color=None):
-        if not hasattr(image, "im"):
-            image = Image.new(image, size, color)
-        self.draw = ImageDraw.Draw(image)
-        self.image = image
-        self.transform = None
-
-    def flush(self):
-        return self.image
-
-    def render(self, op, xy, pen, brush=None):
-        # handle color arguments
-        outline = fill = None
-        width = 1
-        if isinstance(pen, Pen):
-            outline = pen.color
-            width = pen.width
-        elif isinstance(brush, Pen):
-            outline = brush.color
-            width = brush.width
-        if isinstance(brush, Brush):
-            fill = brush.color
-        elif isinstance(pen, Brush):
-            fill = pen.color
-        # handle transformation
-        if self.transform:
-            xy = ImagePath.Path(xy)
-            xy.transform(self.transform)
-        # render the item
-        if op == "line":
-            self.draw.line(xy, fill=outline, width=width)
-        else:
-            getattr(self.draw, op)(xy, fill=fill, outline=outline)
-
-    def settransform(self, offset):
-        """Sets a transformation offset."""
-        (xoffset, yoffset) = offset
-        self.transform = (1, 0, xoffset, 0, 1, yoffset)
-
-    def arc(self, xy, start, end, *options):
-        """
-        Draws an arc (a portion of a circle outline) between the start and end
-        angles, inside the given bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.arc`
-        """
-        self.render("arc", xy, start, end, *options)
-
-    def chord(self, xy, start, end, *options):
-        """
-        Same as :py:meth:`~PIL.ImageDraw2.Draw.arc`, but connects the end points
-        with a straight line.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.chord`
-        """
-        self.render("chord", xy, start, end, *options)
-
-    def ellipse(self, xy, *options):
-        """
-        Draws an ellipse inside the given bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.ellipse`
-        """
-        self.render("ellipse", xy, *options)
-
-    def line(self, xy, *options):
-        """
-        Draws a line between the coordinates in the ``xy`` list.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.line`
-        """
-        self.render("line", xy, *options)
-
-    def pieslice(self, xy, start, end, *options):
-        """
-        Same as arc, but also draws straight lines between the end points and the
-        center of the bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.pieslice`
-        """
-        self.render("pieslice", xy, start, end, *options)
-
-    def polygon(self, xy, *options):
-        """
-        Draws a polygon.
-
-        The polygon outline consists of straight lines between the given
-        coordinates, plus a straight line between the last and the first
-        coordinate.
-
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.polygon`
-        """
-        self.render("polygon", xy, *options)
-
-    def rectangle(self, xy, *options):
-        """
-        Draws a rectangle.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.rectangle`
-        """
-        self.render("rectangle", xy, *options)
-
-    def text(self, xy, text, font):
-        """
-        Draws the string at the given position.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.text`
-        """
-        if self.transform:
-            xy = ImagePath.Path(xy)
-            xy.transform(self.transform)
-        self.draw.text(xy, text, font=font.font, fill=font.color)
-
-    def textsize(self, text, font):
-        """
-        .. deprecated:: 9.2.0
-
-        Return the size of the given string, in pixels.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textsize`
-        """
-        deprecate("textsize", 10, "textbbox or textlength")
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", category=DeprecationWarning)
-            return self.draw.textsize(text, font=font.font)
-
-    def textbbox(self, xy, text, font):
-        """
-        Returns bounding box (in pixels) of given text.
-
-        :return: ``(left, top, right, bottom)`` bounding box
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textbbox`
-        """
-        if self.transform:
-            xy = ImagePath.Path(xy)
-            xy.transform(self.transform)
-        return self.draw.textbbox(xy, text, font=font.font)
-
-    def textlength(self, text, font):
-        """
-        Returns length (in pixels) of given text.
-        This is the amount by which following text should be offset.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textlength`
-        """
-        return self.draw.textlength(text, font=font.font)

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageEnhance.py

@@ -1,103 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# image enhancement classes
-#
-# For a background, see "Image Processing By Interpolation and
-# Extrapolation", Paul Haeberli and Douglas Voorhies.  Available
-# at http://www.graficaobscura.com/interp/index.html
-#
-# History:
-# 1996-03-23 fl  Created
-# 2009-06-16 fl  Fixed mean calculation
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image, ImageFilter, ImageStat
-
-
-class _Enhance:
-    def enhance(self, factor):
-        """
-        Returns an enhanced image.
-
-        :param factor: A floating point value controlling the enhancement.
-                       Factor 1.0 always returns a copy of the original image,
-                       lower factors mean less color (brightness, contrast,
-                       etc), and higher values more. There are no restrictions
-                       on this value.
-        :rtype: :py:class:`~PIL.Image.Image`
-        """
-        return Image.blend(self.degenerate, self.image, factor)
-
-
-class Color(_Enhance):
-    """Adjust image color balance.
-
-    This class can be used to adjust the colour balance of an image, in
-    a manner similar to the controls on a colour TV set. An enhancement
-    factor of 0.0 gives a black and white image. A factor of 1.0 gives
-    the original image.
-    """
-
-    def __init__(self, image):
-        self.image = image
-        self.intermediate_mode = "L"
-        if "A" in image.getbands():
-            self.intermediate_mode = "LA"
-
-        self.degenerate = image.convert(self.intermediate_mode).convert(image.mode)
-
-
-class Contrast(_Enhance):
-    """Adjust image contrast.
-
-    This class can be used to control the contrast of an image, similar
-    to the contrast control on a TV set. An enhancement factor of 0.0
-    gives a solid grey image. A factor of 1.0 gives the original image.
-    """
-
-    def __init__(self, image):
-        self.image = image
-        mean = int(ImageStat.Stat(image.convert("L")).mean[0] + 0.5)
-        self.degenerate = Image.new("L", image.size, mean).convert(image.mode)
-
-        if "A" in image.getbands():
-            self.degenerate.putalpha(image.getchannel("A"))
-
-
-class Brightness(_Enhance):
-    """Adjust image brightness.
-
-    This class can be used to control the brightness of an image.  An
-    enhancement factor of 0.0 gives a black image. A factor of 1.0 gives the
-    original image.
-    """
-
-    def __init__(self, image):
-        self.image = image
-        self.degenerate = Image.new(image.mode, image.size, 0)
-
-        if "A" in image.getbands():
-            self.degenerate.putalpha(image.getchannel("A"))
-
-
-class Sharpness(_Enhance):
-    """Adjust image sharpness.
-
-    This class can be used to adjust the sharpness of an image. An
-    enhancement factor of 0.0 gives a blurred image, a factor of 1.0 gives the
-    original image, and a factor of 2.0 gives a sharpened image.
-    """
-
-    def __init__(self, image):
-        self.image = image
-        self.degenerate = image.filter(ImageFilter.SMOOTH)
-
-        if "A" in image.getbands():
-            self.degenerate.putalpha(image.getchannel("A"))

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageFile.py

@@ -1,754 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# base class for image file handlers
-#
-# history:
-# 1995-09-09 fl   Created
-# 1996-03-11 fl   Fixed load mechanism.
-# 1996-04-15 fl   Added pcx/xbm decoders.
-# 1996-04-30 fl   Added encoders.
-# 1996-12-14 fl   Added load helpers
-# 1997-01-11 fl   Use encode_to_file where possible
-# 1997-08-27 fl   Flush output in _save
-# 1998-03-05 fl   Use memory mapping for some modes
-# 1999-02-04 fl   Use memory mapping also for "I;16" and "I;16B"
-# 1999-05-31 fl   Added image parser
-# 2000-10-12 fl   Set readonly flag on memory-mapped images
-# 2002-03-20 fl   Use better messages for common decoder errors
-# 2003-04-21 fl   Fall back on mmap/map_buffer if map is not available
-# 2003-10-30 fl   Added StubImageFile class
-# 2004-02-25 fl   Made incremental parser more robust
-#
-# Copyright (c) 1997-2004 by Secret Labs AB
-# Copyright (c) 1995-2004 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import io
-import itertools
-import struct
-import sys
-
-from . import Image
-from ._util import is_path
-
-MAXBLOCK = 65536
-
-SAFEBLOCK = 1024 * 1024
-
-LOAD_TRUNCATED_IMAGES = False
-"""Whether or not to load truncated image files. User code may change this."""
-
-ERRORS = {
-    -1: "image buffer overrun error",
-    -2: "decoding error",
-    -3: "unknown error",
-    -8: "bad configuration",
-    -9: "out of memory error",
-}
-"""
-Dict of known error codes returned from :meth:`.PyDecoder.decode`,
-:meth:`.PyEncoder.encode` :meth:`.PyEncoder.encode_to_pyfd` and
-:meth:`.PyEncoder.encode_to_file`.
-"""
-
-
-#
-# --------------------------------------------------------------------
-# Helpers
-
-
-def raise_oserror(error):
-    try:
-        message = Image.core.getcodecstatus(error)
-    except AttributeError:
-        message = ERRORS.get(error)
-    if not message:
-        message = f"decoder error {error}"
-    raise OSError(message + " when reading image file")
-
-
-def _tilesort(t):
-    # sort on offset
-    return t[2]
-
-
-#
-# --------------------------------------------------------------------
-# ImageFile base class
-
-
-class ImageFile(Image.Image):
-    """Base class for image file format handlers."""
-
-    def __init__(self, fp=None, filename=None):
-        super().__init__()
-
-        self._min_frame = 0
-
-        self.custom_mimetype = None
-
-        self.tile = None
-        """ A list of tile descriptors, or ``None`` """
-
-        self.readonly = 1  # until we know better
-
-        self.decoderconfig = ()
-        self.decodermaxblock = MAXBLOCK
-
-        if is_path(fp):
-            # filename
-            self.fp = open(fp, "rb")
-            self.filename = fp
-            self._exclusive_fp = True
-        else:
-            # stream
-            self.fp = fp
-            self.filename = filename
-            # can be overridden
-            self._exclusive_fp = None
-
-        try:
-            try:
-                self._open()
-            except (
-                IndexError,  # end of data
-                TypeError,  # end of data (ord)
-                KeyError,  # unsupported mode
-                EOFError,  # got header but not the first frame
-                struct.error,
-            ) as v:
-                raise SyntaxError(v) from v
-
-            if not self.mode or self.size[0] <= 0 or self.size[1] <= 0:
-                raise SyntaxError("not identified by this driver")
-        except BaseException:
-            # close the file only if we have opened it this constructor
-            if self._exclusive_fp:
-                self.fp.close()
-            raise
-
-    def get_format_mimetype(self):
-        if self.custom_mimetype:
-            return self.custom_mimetype
-        if self.format is not None:
-            return Image.MIME.get(self.format.upper())
-
-    def verify(self):
-        """Check file integrity"""
-
-        # raise exception if something's wrong.  must be called
-        # directly after open, and closes file when finished.
-        if self._exclusive_fp:
-            self.fp.close()
-        self.fp = None
-
-    def load(self):
-        """Load image data based on tile list"""
-
-        if self.tile is None:
-            raise OSError("cannot load this image")
-
-        pixel = Image.Image.load(self)
-        if not self.tile:
-            return pixel
-
-        self.map = None
-        use_mmap = self.filename and len(self.tile) == 1
-        # As of pypy 2.1.0, memory mapping was failing here.
-        use_mmap = use_mmap and not hasattr(sys, "pypy_version_info")
-
-        readonly = 0
-
-        # look for read/seek overrides
-        try:
-            read = self.load_read
-            # don't use mmap if there are custom read/seek functions
-            use_mmap = False
-        except AttributeError:
-            read = self.fp.read
-
-        try:
-            seek = self.load_seek
-            use_mmap = False
-        except AttributeError:
-            seek = self.fp.seek
-
-        if use_mmap:
-            # try memory mapping
-            decoder_name, extents, offset, args = self.tile[0]
-            if (
-                decoder_name == "raw"
-                and len(args) >= 3
-                and args[0] == self.mode
-                and args[0] in Image._MAPMODES
-            ):
-                try:
-                    # use mmap, if possible
-                    import mmap
-
-                    with open(self.filename) as fp:
-                        self.map = mmap.mmap(fp.fileno(), 0, access=mmap.ACCESS_READ)
-                    if offset + self.size[1] * args[1] > self.map.size():
-                        # buffer is not large enough
-                        raise OSError
-                    self.im = Image.core.map_buffer(
-                        self.map, self.size, decoder_name, offset, args
-                    )
-                    readonly = 1
-                    # After trashing self.im,
-                    # we might need to reload the palette data.
-                    if self.palette:
-                        self.palette.dirty = 1
-                except (AttributeError, OSError, ImportError):
-                    self.map = None
-
-        self.load_prepare()
-        err_code = -3  # initialize to unknown error
-        if not self.map:
-            # sort tiles in file order
-            self.tile.sort(key=_tilesort)
-
-            try:
-                # FIXME: This is a hack to handle TIFF's JpegTables tag.
-                prefix = self.tile_prefix
-            except AttributeError:
-                prefix = b""
-
-            # Remove consecutive duplicates that only differ by their offset
-            self.tile = [
-                list(tiles)[-1]
-                for _, tiles in itertools.groupby(
-                    self.tile, lambda tile: (tile[0], tile[1], tile[3])
-                )
-            ]
-            for decoder_name, extents, offset, args in self.tile:
-                seek(offset)
-                decoder = Image._getdecoder(
-                    self.mode, decoder_name, args, self.decoderconfig
-                )
-                try:
-                    decoder.setimage(self.im, extents)
-                    if decoder.pulls_fd:
-                        decoder.setfd(self.fp)
-                        err_code = decoder.decode(b"")[1]
-                    else:
-                        b = prefix
-                        while True:
-                            try:
-                                s = read(self.decodermaxblock)
-                            except (IndexError, struct.error) as e:
-                                # truncated png/gif
-                                if LOAD_TRUNCATED_IMAGES:
-                                    break
-                                else:
-                                    raise OSError("image file is truncated") from e
-
-                            if not s:  # truncated jpeg
-                                if LOAD_TRUNCATED_IMAGES:
-                                    break
-                                else:
-                                    raise OSError(
-                                        "image file is truncated "
-                                        f"({len(b)} bytes not processed)"
-                                    )
-
-                            b = b + s
-                            n, err_code = decoder.decode(b)
-                            if n < 0:
-                                break
-                            b = b[n:]
-                finally:
-                    # Need to cleanup here to prevent leaks
-                    decoder.cleanup()
-
-        self.tile = []
-        self.readonly = readonly
-
-        self.load_end()
-
-        if self._exclusive_fp and self._close_exclusive_fp_after_loading:
-            self.fp.close()
-        self.fp = None
-
-        if not self.map and not LOAD_TRUNCATED_IMAGES and err_code < 0:
-            # still raised if decoder fails to return anything
-            raise_oserror(err_code)
-
-        return Image.Image.load(self)
-
-    def load_prepare(self):
-        # create image memory if necessary
-        if not self.im or self.im.mode != self.mode or self.im.size != self.size:
-            self.im = Image.core.new(self.mode, self.size)
-        # create palette (optional)
-        if self.mode == "P":
-            Image.Image.load(self)
-
-    def load_end(self):
-        # may be overridden
-        pass
-
-    # may be defined for contained formats
-    # def load_seek(self, pos):
-    #     pass
-
-    # may be defined for blocked formats (e.g. PNG)
-    # def load_read(self, bytes):
-    #     pass
-
-    def _seek_check(self, frame):
-        if (
-            frame < self._min_frame
-            # Only check upper limit on frames if additional seek operations
-            # are not required to do so
-            or (
-                not (hasattr(self, "_n_frames") and self._n_frames is None)
-                and frame >= self.n_frames + self._min_frame
-            )
-        ):
-            raise EOFError("attempt to seek outside sequence")
-
-        return self.tell() != frame
-
-
-class StubImageFile(ImageFile):
-    """
-    Base class for stub image loaders.
-
-    A stub loader is an image loader that can identify files of a
-    certain format, but relies on external code to load the file.
-    """
-
-    def _open(self):
-        raise NotImplementedError("StubImageFile subclass must implement _open")
-
-    def load(self):
-        loader = self._load()
-        if loader is None:
-            raise OSError(f"cannot find loader for this {self.format} file")
-        image = loader.load(self)
-        assert image is not None
-        # become the other object (!)
-        self.__class__ = image.__class__
-        self.__dict__ = image.__dict__
-        return image.load()
-
-    def _load(self):
-        """(Hook) Find actual image loader."""
-        raise NotImplementedError("StubImageFile subclass must implement _load")
-
-
-class Parser:
-    """
-    Incremental image parser.  This class implements the standard
-    feed/close consumer interface.
-    """
-
-    incremental = None
-    image = None
-    data = None
-    decoder = None
-    offset = 0
-    finished = 0
-
-    def reset(self):
-        """
-        (Consumer) Reset the parser.  Note that you can only call this
-        method immediately after you've created a parser; parser
-        instances cannot be reused.
-        """
-        assert self.data is None, "cannot reuse parsers"
-
-    def feed(self, data):
-        """
-        (Consumer) Feed data to the parser.
-
-        :param data: A string buffer.
-        :exception OSError: If the parser failed to parse the image file.
-        """
-        # collect data
-
-        if self.finished:
-            return
-
-        if self.data is None:
-            self.data = data
-        else:
-            self.data = self.data + data
-
-        # parse what we have
-        if self.decoder:
-
-            if self.offset > 0:
-                # skip header
-                skip = min(len(self.data), self.offset)
-                self.data = self.data[skip:]
-                self.offset = self.offset - skip
-                if self.offset > 0 or not self.data:
-                    return
-
-            n, e = self.decoder.decode(self.data)
-
-            if n < 0:
-                # end of stream
-                self.data = None
-                self.finished = 1
-                if e < 0:
-                    # decoding error
-                    self.image = None
-                    raise_oserror(e)
-                else:
-                    # end of image
-                    return
-            self.data = self.data[n:]
-
-        elif self.image:
-
-            # if we end up here with no decoder, this file cannot
-            # be incrementally parsed.  wait until we've gotten all
-            # available data
-            pass
-
-        else:
-
-            # attempt to open this file
-            try:
-                with io.BytesIO(self.data) as fp:
-                    im = Image.open(fp)
-            except OSError:
-                # traceback.print_exc()
-                pass  # not enough data
-            else:
-                flag = hasattr(im, "load_seek") or hasattr(im, "load_read")
-                if flag or len(im.tile) != 1:
-                    # custom load code, or multiple tiles
-                    self.decode = None
-                else:
-                    # initialize decoder
-                    im.load_prepare()
-                    d, e, o, a = im.tile[0]
-                    im.tile = []
-                    self.decoder = Image._getdecoder(im.mode, d, a, im.decoderconfig)
-                    self.decoder.setimage(im.im, e)
-
-                    # calculate decoder offset
-                    self.offset = o
-                    if self.offset <= len(self.data):
-                        self.data = self.data[self.offset :]
-                        self.offset = 0
-
-                self.image = im
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
-    def close(self):
-        """
-        (Consumer) Close the stream.
-
-        :returns: An image object.
-        :exception OSError: If the parser failed to parse the image file either
-                            because it cannot be identified or cannot be
-                            decoded.
-        """
-        # finish decoding
-        if self.decoder:
-            # get rid of what's left in the buffers
-            self.feed(b"")
-            self.data = self.decoder = None
-            if not self.finished:
-                raise OSError("image was incomplete")
-        if not self.image:
-            raise OSError("cannot parse this image")
-        if self.data:
-            # incremental parsing not possible; reopen the file
-            # not that we have all data
-            with io.BytesIO(self.data) as fp:
-                try:
-                    self.image = Image.open(fp)
-                finally:
-                    self.image.load()
-        return self.image
-
-
-# --------------------------------------------------------------------
-
-
-def _save(im, fp, tile, bufsize=0):
-    """Helper to save image based on tile list
-
-    :param im: Image object.
-    :param fp: File object.
-    :param tile: Tile list.
-    :param bufsize: Optional buffer size
-    """
-
-    im.load()
-    if not hasattr(im, "encoderconfig"):
-        im.encoderconfig = ()
-    tile.sort(key=_tilesort)
-    # FIXME: make MAXBLOCK a configuration parameter
-    # It would be great if we could have the encoder specify what it needs
-    # But, it would need at least the image size in most cases. RawEncode is
-    # a tricky case.
-    bufsize = max(MAXBLOCK, bufsize, im.size[0] * 4)  # see RawEncode.c
-    try:
-        fh = fp.fileno()
-        fp.flush()
-        _encode_tile(im, fp, tile, bufsize, fh)
-    except (AttributeError, io.UnsupportedOperation) as exc:
-        _encode_tile(im, fp, tile, bufsize, None, exc)
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-
-def _encode_tile(im, fp, tile, bufsize, fh, exc=None):
-    for e, b, o, a in tile:
-        if o > 0:
-            fp.seek(o)
-        encoder = Image._getencoder(im.mode, e, a, im.encoderconfig)
-        try:
-            encoder.setimage(im.im, b)
-            if encoder.pushes_fd:
-                encoder.setfd(fp)
-                l, s = encoder.encode_to_pyfd()
-            else:
-                if exc:
-                    # compress to Python file-compatible object
-                    while True:
-                        l, s, d = encoder.encode(bufsize)
-                        fp.write(d)
-                        if s:
-                            break
-                else:
-                    # slight speedup: compress to real file object
-                    s = encoder.encode_to_file(fh, bufsize)
-            if s < 0:
-                raise OSError(f"encoder error {s} when writing image file") from exc
-        finally:
-            encoder.cleanup()
-
-
-def _safe_read(fp, size):
-    """
-    Reads large blocks in a safe way.  Unlike fp.read(n), this function
-    doesn't trust the user.  If the requested size is larger than
-    SAFEBLOCK, the file is read block by block.
-
-    :param fp: File handle.  Must implement a <b>read</b> method.
-    :param size: Number of bytes to read.
-    :returns: A string containing <i>size</i> bytes of data.
-
-    Raises an OSError if the file is truncated and the read cannot be completed
-
-    """
-    if size <= 0:
-        return b""
-    if size <= SAFEBLOCK:
-        data = fp.read(size)
-        if len(data) < size:
-            raise OSError("Truncated File Read")
-        return data
-    data = []
-    remaining_size = size
-    while remaining_size > 0:
-        block = fp.read(min(remaining_size, SAFEBLOCK))
-        if not block:
-            break
-        data.append(block)
-        remaining_size -= len(block)
-    if sum(len(d) for d in data) < size:
-        raise OSError("Truncated File Read")
-    return b"".join(data)
-
-
-class PyCodecState:
-    def __init__(self):
-        self.xsize = 0
-        self.ysize = 0
-        self.xoff = 0
-        self.yoff = 0
-
-    def extents(self):
-        return self.xoff, self.yoff, self.xoff + self.xsize, self.yoff + self.ysize
-
-
-class PyCodec:
-    def __init__(self, mode, *args):
-        self.im = None
-        self.state = PyCodecState()
-        self.fd = None
-        self.mode = mode
-        self.init(args)
-
-    def init(self, args):
-        """
-        Override to perform codec specific initialization
-
-        :param args: Array of args items from the tile entry
-        :returns: None
-        """
-        self.args = args
-
-    def cleanup(self):
-        """
-        Override to perform codec specific cleanup
-
-        :returns: None
-        """
-        pass
-
-    def setfd(self, fd):
-        """
-        Called from ImageFile to set the Python file-like object
-
-        :param fd: A Python file-like object
-        :returns: None
-        """
-        self.fd = fd
-
-    def setimage(self, im, extents=None):
-        """
-        Called from ImageFile to set the core output image for the codec
-
-        :param im: A core image object
-        :param extents: a 4 tuple of (x0, y0, x1, y1) defining the rectangle
-            for this tile
-        :returns: None
-        """
-
-        # following c code
-        self.im = im
-
-        if extents:
-            (x0, y0, x1, y1) = extents
-        else:
-            (x0, y0, x1, y1) = (0, 0, 0, 0)
-
-        if x0 == 0 and x1 == 0:
-            self.state.xsize, self.state.ysize = self.im.size
-        else:
-            self.state.xoff = x0
-            self.state.yoff = y0
-            self.state.xsize = x1 - x0
-            self.state.ysize = y1 - y0
-
-        if self.state.xsize <= 0 or self.state.ysize <= 0:
-            raise ValueError("Size cannot be negative")
-
-        if (
-            self.state.xsize + self.state.xoff > self.im.size[0]
-            or self.state.ysize + self.state.yoff > self.im.size[1]
-        ):
-            raise ValueError("Tile cannot extend outside image")
-
-
-class PyDecoder(PyCodec):
-    """
-    Python implementation of a format decoder. Override this class and
-    add the decoding logic in the :meth:`decode` method.
-
-    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
-    """
-
-    _pulls_fd = False
-
-    @property
-    def pulls_fd(self):
-        return self._pulls_fd
-
-    def decode(self, buffer):
-        """
-        Override to perform the decoding process.
-
-        :param buffer: A bytes object with the data to be decoded.
-        :returns: A tuple of ``(bytes consumed, errcode)``.
-            If finished with decoding return -1 for the bytes consumed.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        raise NotImplementedError()
-
-    def set_as_raw(self, data, rawmode=None):
-        """
-        Convenience method to set the internal image from a stream of raw data
-
-        :param data: Bytes to be set
-        :param rawmode: The rawmode to be used for the decoder.
-            If not specified, it will default to the mode of the image
-        :returns: None
-        """
-
-        if not rawmode:
-            rawmode = self.mode
-        d = Image._getdecoder(self.mode, "raw", rawmode)
-        d.setimage(self.im, self.state.extents())
-        s = d.decode(data)
-
-        if s[0] >= 0:
-            raise ValueError("not enough image data")
-        if s[1] != 0:
-            raise ValueError("cannot decode image data")
-
-
-class PyEncoder(PyCodec):
-    """
-    Python implementation of a format encoder. Override this class and
-    add the decoding logic in the :meth:`encode` method.
-
-    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
-    """
-
-    _pushes_fd = False
-
-    @property
-    def pushes_fd(self):
-        return self._pushes_fd
-
-    def encode(self, bufsize):
-        """
-        Override to perform the encoding process.
-
-        :param bufsize: Buffer size.
-        :returns: A tuple of ``(bytes encoded, errcode, bytes)``.
-            If finished with encoding return 1 for the error code.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        raise NotImplementedError()
-
-    def encode_to_pyfd(self):
-        """
-        If ``pushes_fd`` is ``True``, then this method will be used,
-        and ``encode()`` will only be called once.
-
-        :returns: A tuple of ``(bytes consumed, errcode)``.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        if not self.pushes_fd:
-            return 0, -8  # bad configuration
-        bytes_consumed, errcode, data = self.encode(0)
-        if data:
-            self.fd.write(data)
-        return bytes_consumed, errcode
-
-    def encode_to_file(self, fh, bufsize):
-        """
-        :param fh: File handle.
-        :param bufsize: Buffer size.
-
-        :returns: If finished successfully, return 0.
-            Otherwise, return an error code. Err codes are from
-            :data:`.ImageFile.ERRORS`.
-        """
-        errcode = 0
-        while errcode == 0:
-            status, errcode, buf = self.encode(bufsize)
-            if status > 0:
-                fh.write(buf[status:])
-        return errcode

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageFilter.py

@@ -1,538 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# standard filters
-#
-# History:
-# 1995-11-27 fl   Created
-# 2002-06-08 fl   Added rank and mode filters
-# 2003-09-15 fl   Fixed rank calculation in rank filter; added expand call
-#
-# Copyright (c) 1997-2003 by Secret Labs AB.
-# Copyright (c) 1995-2002 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-import functools
-
-
-class Filter:
-    pass
-
-
-class MultibandFilter(Filter):
-    pass
-
-
-class BuiltinFilter(MultibandFilter):
-    def filter(self, image):
-        if image.mode == "P":
-            raise ValueError("cannot filter palette images")
-        return image.filter(*self.filterargs)
-
-
-class Kernel(BuiltinFilter):
-    """
-    Create a convolution kernel.  The current version only
-    supports 3x3 and 5x5 integer and floating point kernels.
-
-    In the current version, kernels can only be applied to
-    "L" and "RGB" images.
-
-    :param size: Kernel size, given as (width, height). In the current
-                    version, this must be (3,3) or (5,5).
-    :param kernel: A sequence containing kernel weights.
-    :param scale: Scale factor. If given, the result for each pixel is
-                    divided by this value.  The default is the sum of the
-                    kernel weights.
-    :param offset: Offset. If given, this value is added to the result,
-                    after it has been divided by the scale factor.
-    """
-
-    name = "Kernel"
-
-    def __init__(self, size, kernel, scale=None, offset=0):
-        if scale is None:
-            # default scale is sum of kernel
-            scale = functools.reduce(lambda a, b: a + b, kernel)
-        if size[0] * size[1] != len(kernel):
-            raise ValueError("not enough coefficients in kernel")
-        self.filterargs = size, scale, offset, kernel
-
-
-class RankFilter(Filter):
-    """
-    Create a rank filter.  The rank filter sorts all pixels in
-    a window of the given size, and returns the ``rank``'th value.
-
-    :param size: The kernel size, in pixels.
-    :param rank: What pixel value to pick.  Use 0 for a min filter,
-                 ``size * size / 2`` for a median filter, ``size * size - 1``
-                 for a max filter, etc.
-    """
-
-    name = "Rank"
-
-    def __init__(self, size, rank):
-        self.size = size
-        self.rank = rank
-
-    def filter(self, image):
-        if image.mode == "P":
-            raise ValueError("cannot filter palette images")
-        image = image.expand(self.size // 2, self.size // 2)
-        return image.rankfilter(self.size, self.rank)
-
-
-class MedianFilter(RankFilter):
-    """
-    Create a median filter. Picks the median pixel value in a window with the
-    given size.
-
-    :param size: The kernel size, in pixels.
-    """
-
-    name = "Median"
-
-    def __init__(self, size=3):
-        self.size = size
-        self.rank = size * size // 2
-
-
-class MinFilter(RankFilter):
-    """
-    Create a min filter.  Picks the lowest pixel value in a window with the
-    given size.
-
-    :param size: The kernel size, in pixels.
-    """
-
-    name = "Min"
-
-    def __init__(self, size=3):
-        self.size = size
-        self.rank = 0
-
-
-class MaxFilter(RankFilter):
-    """
-    Create a max filter.  Picks the largest pixel value in a window with the
-    given size.
-
-    :param size: The kernel size, in pixels.
-    """
-
-    name = "Max"
-
-    def __init__(self, size=3):
-        self.size = size
-        self.rank = size * size - 1
-
-
-class ModeFilter(Filter):
-    """
-    Create a mode filter. Picks the most frequent pixel value in a box with the
-    given size.  Pixel values that occur only once or twice are ignored; if no
-    pixel value occurs more than twice, the original pixel value is preserved.
-
-    :param size: The kernel size, in pixels.
-    """
-
-    name = "Mode"
-
-    def __init__(self, size=3):
-        self.size = size
-
-    def filter(self, image):
-        return image.modefilter(self.size)
-
-
-class GaussianBlur(MultibandFilter):
-    """Blurs the image with a sequence of extended box filters, which
-    approximates a Gaussian kernel. For details on accuracy see
-    <https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf>
-
-    :param radius: Standard deviation of the Gaussian kernel.
-    """
-
-    name = "GaussianBlur"
-
-    def __init__(self, radius=2):
-        self.radius = radius
-
-    def filter(self, image):
-        return image.gaussian_blur(self.radius)
-
-
-class BoxBlur(MultibandFilter):
-    """Blurs the image by setting each pixel to the average value of the pixels
-    in a square box extending radius pixels in each direction.
-    Supports float radius of arbitrary size. Uses an optimized implementation
-    which runs in linear time relative to the size of the image
-    for any radius value.
-
-    :param radius: Size of the box in one direction. Radius 0 does not blur,
-                   returns an identical image. Radius 1 takes 1 pixel
-                   in each direction, i.e. 9 pixels in total.
-    """
-
-    name = "BoxBlur"
-
-    def __init__(self, radius):
-        self.radius = radius
-
-    def filter(self, image):
-        return image.box_blur(self.radius)
-
-
-class UnsharpMask(MultibandFilter):
-    """Unsharp mask filter.
-
-    See Wikipedia's entry on `digital unsharp masking`_ for an explanation of
-    the parameters.
-
-    :param radius: Blur Radius
-    :param percent: Unsharp strength, in percent
-    :param threshold: Threshold controls the minimum brightness change that
-      will be sharpened
-
-    .. _digital unsharp masking: https://en.wikipedia.org/wiki/Unsharp_masking#Digital_unsharp_masking
-
-    """  # noqa: E501
-
-    name = "UnsharpMask"
-
-    def __init__(self, radius=2, percent=150, threshold=3):
-        self.radius = radius
-        self.percent = percent
-        self.threshold = threshold
-
-    def filter(self, image):
-        return image.unsharp_mask(self.radius, self.percent, self.threshold)
-
-
-class BLUR(BuiltinFilter):
-    name = "Blur"
-    # fmt: off
-    filterargs = (5, 5), 16, 0, (
-        1, 1, 1, 1, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 1, 1, 1, 1,
-    )
-    # fmt: on
-
-
-class CONTOUR(BuiltinFilter):
-    name = "Contour"
-    # fmt: off
-    filterargs = (3, 3), 1, 255, (
-        -1, -1, -1,
-        -1,  8, -1,
-        -1, -1, -1,
-    )
-    # fmt: on
-
-
-class DETAIL(BuiltinFilter):
-    name = "Detail"
-    # fmt: off
-    filterargs = (3, 3), 6, 0, (
-        0,  -1,  0,
-        -1, 10, -1,
-        0,  -1,  0,
-    )
-    # fmt: on
-
-
-class EDGE_ENHANCE(BuiltinFilter):
-    name = "Edge-enhance"
-    # fmt: off
-    filterargs = (3, 3), 2, 0, (
-        -1, -1, -1,
-        -1, 10, -1,
-        -1, -1, -1,
-    )
-    # fmt: on
-
-
-class EDGE_ENHANCE_MORE(BuiltinFilter):
-    name = "Edge-enhance More"
-    # fmt: off
-    filterargs = (3, 3), 1, 0, (
-        -1, -1, -1,
-        -1,  9, -1,
-        -1, -1, -1,
-    )
-    # fmt: on
-
-
-class EMBOSS(BuiltinFilter):
-    name = "Emboss"
-    # fmt: off
-    filterargs = (3, 3), 1, 128, (
-        -1, 0, 0,
-        0,  1, 0,
-        0,  0, 0,
-    )
-    # fmt: on
-
-
-class FIND_EDGES(BuiltinFilter):
-    name = "Find Edges"
-    # fmt: off
-    filterargs = (3, 3), 1, 0, (
-        -1, -1, -1,
-        -1,  8, -1,
-        -1, -1, -1,
-    )
-    # fmt: on
-
-
-class SHARPEN(BuiltinFilter):
-    name = "Sharpen"
-    # fmt: off
-    filterargs = (3, 3), 16, 0, (
-        -2, -2, -2,
-        -2, 32, -2,
-        -2, -2, -2,
-    )
-    # fmt: on
-
-
-class SMOOTH(BuiltinFilter):
-    name = "Smooth"
-    # fmt: off
-    filterargs = (3, 3), 13, 0, (
-        1, 1, 1,
-        1, 5, 1,
-        1, 1, 1,
-    )
-    # fmt: on
-
-
-class SMOOTH_MORE(BuiltinFilter):
-    name = "Smooth More"
-    # fmt: off
-    filterargs = (5, 5), 100, 0, (
-        1, 1,  1, 1, 1,
-        1, 5,  5, 5, 1,
-        1, 5, 44, 5, 1,
-        1, 5,  5, 5, 1,
-        1, 1,  1, 1, 1,
-    )
-    # fmt: on
-
-
-class Color3DLUT(MultibandFilter):
-    """Three-dimensional color lookup table.
-
-    Transforms 3-channel pixels using the values of the channels as coordinates
-    in the 3D lookup table and interpolating the nearest elements.
-
-    This method allows you to apply almost any color transformation
-    in constant time by using pre-calculated decimated tables.
-
-    .. versionadded:: 5.2.0
-
-    :param size: Size of the table. One int or tuple of (int, int, int).
-                 Minimal size in any dimension is 2, maximum is 65.
-    :param table: Flat lookup table. A list of ``channels * size**3``
-                  float elements or a list of ``size**3`` channels-sized
-                  tuples with floats. Channels are changed first,
-                  then first dimension, then second, then third.
-                  Value 0.0 corresponds lowest value of output, 1.0 highest.
-    :param channels: Number of channels in the table. Could be 3 or 4.
-                     Default is 3.
-    :param target_mode: A mode for the result image. Should have not less
-                        than ``channels`` channels. Default is ``None``,
-                        which means that mode wouldn't be changed.
-    """
-
-    name = "Color 3D LUT"
-
-    def __init__(self, size, table, channels=3, target_mode=None, **kwargs):
-        if channels not in (3, 4):
-            raise ValueError("Only 3 or 4 output channels are supported")
-        self.size = size = self._check_size(size)
-        self.channels = channels
-        self.mode = target_mode
-
-        # Hidden flag `_copy_table=False` could be used to avoid extra copying
-        # of the table if the table is specially made for the constructor.
-        copy_table = kwargs.get("_copy_table", True)
-        items = size[0] * size[1] * size[2]
-        wrong_size = False
-
-        numpy = None
-        if hasattr(table, "shape"):
-            try:
-                import numpy
-            except ImportError:  # pragma: no cover
-                pass
-
-        if numpy and isinstance(table, numpy.ndarray):
-            if copy_table:
-                table = table.copy()
-
-            if table.shape in [
-                (items * channels,),
-                (items, channels),
-                (size[2], size[1], size[0], channels),
-            ]:
-                table = table.reshape(items * channels)
-            else:
-                wrong_size = True
-
-        else:
-            if copy_table:
-                table = list(table)
-
-            # Convert to a flat list
-            if table and isinstance(table[0], (list, tuple)):
-                table, raw_table = [], table
-                for pixel in raw_table:
-                    if len(pixel) != channels:
-                        raise ValueError(
-                            "The elements of the table should "
-                            "have a length of {}.".format(channels)
-                        )
-                    table.extend(pixel)
-
-        if wrong_size or len(table) != items * channels:
-            raise ValueError(
-                "The table should have either channels * size**3 float items "
-                "or size**3 items of channels-sized tuples with floats. "
-                f"Table should be: {channels}x{size[0]}x{size[1]}x{size[2]}. "
-                f"Actual length: {len(table)}"
-            )
-        self.table = table
-
-    @staticmethod
-    def _check_size(size):
-        try:
-            _, _, _ = size
-        except ValueError as e:
-            raise ValueError(
-                "Size should be either an integer or a tuple of three integers."
-            ) from e
-        except TypeError:
-            size = (size, size, size)
-        size = [int(x) for x in size]
-        for size_1d in size:
-            if not 2 <= size_1d <= 65:
-                raise ValueError("Size should be in [2, 65] range.")
-        return size
-
-    @classmethod
-    def generate(cls, size, callback, channels=3, target_mode=None):
-        """Generates new LUT using provided callback.
-
-        :param size: Size of the table. Passed to the constructor.
-        :param callback: Function with three parameters which correspond
-                         three color channels. Will be called ``size**3``
-                         times with values from 0.0 to 1.0 and should return
-                         a tuple with ``channels`` elements.
-        :param channels: The number of channels which should return callback.
-        :param target_mode: Passed to the constructor of the resulting
-                            lookup table.
-        """
-        size_1d, size_2d, size_3d = cls._check_size(size)
-        if channels not in (3, 4):
-            raise ValueError("Only 3 or 4 output channels are supported")
-
-        table = [0] * (size_1d * size_2d * size_3d * channels)
-        idx_out = 0
-        for b in range(size_3d):
-            for g in range(size_2d):
-                for r in range(size_1d):
-                    table[idx_out : idx_out + channels] = callback(
-                        r / (size_1d - 1), g / (size_2d - 1), b / (size_3d - 1)
-                    )
-                    idx_out += channels
-
-        return cls(
-            (size_1d, size_2d, size_3d),
-            table,
-            channels=channels,
-            target_mode=target_mode,
-            _copy_table=False,
-        )
-
-    def transform(self, callback, with_normals=False, channels=None, target_mode=None):
-        """Transforms the table values using provided callback and returns
-        a new LUT with altered values.
-
-        :param callback: A function which takes old lookup table values
-                         and returns a new set of values. The number
-                         of arguments which function should take is
-                         ``self.channels`` or ``3 + self.channels``
-                         if ``with_normals`` flag is set.
-                         Should return a tuple of ``self.channels`` or
-                         ``channels`` elements if it is set.
-        :param with_normals: If true, ``callback`` will be called with
-                             coordinates in the color cube as the first
-                             three arguments. Otherwise, ``callback``
-                             will be called only with actual color values.
-        :param channels: The number of channels in the resulting lookup table.
-        :param target_mode: Passed to the constructor of the resulting
-                            lookup table.
-        """
-        if channels not in (None, 3, 4):
-            raise ValueError("Only 3 or 4 output channels are supported")
-        ch_in = self.channels
-        ch_out = channels or ch_in
-        size_1d, size_2d, size_3d = self.size
-
-        table = [0] * (size_1d * size_2d * size_3d * ch_out)
-        idx_in = 0
-        idx_out = 0
-        for b in range(size_3d):
-            for g in range(size_2d):
-                for r in range(size_1d):
-                    values = self.table[idx_in : idx_in + ch_in]
-                    if with_normals:
-                        values = callback(
-                            r / (size_1d - 1),
-                            g / (size_2d - 1),
-                            b / (size_3d - 1),
-                            *values,
-                        )
-                    else:
-                        values = callback(*values)
-                    table[idx_out : idx_out + ch_out] = values
-                    idx_in += ch_in
-                    idx_out += ch_out
-
-        return type(self)(
-            self.size,
-            table,
-            channels=ch_out,
-            target_mode=target_mode or self.mode,
-            _copy_table=False,
-        )
-
-    def __repr__(self):
-        r = [
-            f"{self.__class__.__name__} from {self.table.__class__.__name__}",
-            "size={:d}x{:d}x{:d}".format(*self.size),
-            f"channels={self.channels:d}",
-        ]
-        if self.mode:
-            r.append(f"target_mode={self.mode}")
-        return "<{}>".format(" ".join(r))
-
-    def filter(self, image):
-        from . import Image
-
-        return image.color_lut_3d(
-            self.mode or image.mode,
-            Image.Resampling.BILINEAR,
-            self.channels,
-            self.size[0],
-            self.size[1],
-            self.size[2],
-            self.table,
-        )

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageGrab.py

@@ -1,135 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# screen grabber
-#
-# History:
-# 2001-04-26 fl  created
-# 2001-09-17 fl  use builtin driver, if present
-# 2002-11-19 fl  added grabclipboard support
-#
-# Copyright (c) 2001-2002 by Secret Labs AB
-# Copyright (c) 2001-2002 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-
-from . import Image
-
-
-def grab(bbox=None, include_layered_windows=False, all_screens=False, xdisplay=None):
-    if xdisplay is None:
-        if sys.platform == "darwin":
-            fh, filepath = tempfile.mkstemp(".png")
-            os.close(fh)
-            args = ["screencapture"]
-            if bbox:
-                left, top, right, bottom = bbox
-                args += ["-R", f"{left},{top},{right-left},{bottom-top}"]
-            subprocess.call(args + ["-x", filepath])
-            im = Image.open(filepath)
-            im.load()
-            os.unlink(filepath)
-            if bbox:
-                im_resized = im.resize((right - left, bottom - top))
-                im.close()
-                return im_resized
-            return im
-        elif sys.platform == "win32":
-            offset, size, data = Image.core.grabscreen_win32(
-                include_layered_windows, all_screens
-            )
-            im = Image.frombytes(
-                "RGB",
-                size,
-                data,
-                # RGB, 32-bit line padding, origin lower left corner
-                "raw",
-                "BGR",
-                (size[0] * 3 + 3) & -4,
-                -1,
-            )
-            if bbox:
-                x0, y0 = offset
-                left, top, right, bottom = bbox
-                im = im.crop((left - x0, top - y0, right - x0, bottom - y0))
-            return im
-        elif shutil.which("gnome-screenshot"):
-            fh, filepath = tempfile.mkstemp(".png")
-            os.close(fh)
-            subprocess.call(["gnome-screenshot", "-f", filepath])
-            im = Image.open(filepath)
-            im.load()
-            os.unlink(filepath)
-            if bbox:
-                im_cropped = im.crop(bbox)
-                im.close()
-                return im_cropped
-            return im
-    # use xdisplay=None for default display on non-win32/macOS systems
-    if not Image.core.HAVE_XCB:
-        raise OSError("Pillow was built without XCB support")
-    size, data = Image.core.grabscreen_x11(xdisplay)
-    im = Image.frombytes("RGB", size, data, "raw", "BGRX", size[0] * 4, 1)
-    if bbox:
-        im = im.crop(bbox)
-    return im
-
-
-def grabclipboard():
-    if sys.platform == "darwin":
-        fh, filepath = tempfile.mkstemp(".jpg")
-        os.close(fh)
-        commands = [
-            'set theFile to (open for access POSIX file "'
-            + filepath
-            + '" with write permission)',
-            "try",
-            "    write (the clipboard as JPEG picture) to theFile",
-            "end try",
-            "close access theFile",
-        ]
-        script = ["osascript"]
-        for command in commands:
-            script += ["-e", command]
-        subprocess.call(script)
-
-        im = None
-        if os.stat(filepath).st_size != 0:
-            im = Image.open(filepath)
-            im.load()
-        os.unlink(filepath)
-        return im
-    elif sys.platform == "win32":
-        fmt, data = Image.core.grabclipboard_win32()
-        if fmt == "file":  # CF_HDROP
-            import struct
-
-            o = struct.unpack_from("I", data)[0]
-            if data[16] != 0:
-                files = data[o:].decode("utf-16le").split("\0")
-            else:
-                files = data[o:].decode("mbcs").split("\0")
-            return files[: files.index("")]
-        if isinstance(data, bytes):
-            import io
-
-            data = io.BytesIO(data)
-            if fmt == "png":
-                from . import PngImagePlugin
-
-                return PngImagePlugin.PngImageFile(data)
-            elif fmt == "DIB":
-                from . import BmpImagePlugin
-
-                return BmpImagePlugin.DibImageFile(data)
-        return None
-    else:
-        raise NotImplementedError("ImageGrab.grabclipboard() is macOS and Windows only")

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageMath.py

@@ -1,259 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# a simple math add-on for the Python Imaging Library
-#
-# History:
-# 1999-02-15 fl   Original PIL Plus release
-# 2005-05-05 fl   Simplified and cleaned up for PIL 1.1.6
-# 2005-09-12 fl   Fixed int() and float() for Python 2.4.1
-#
-# Copyright (c) 1999-2005 by Secret Labs AB
-# Copyright (c) 2005 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import builtins
-
-from . import Image, _imagingmath
-
-
-def _isconstant(v):
-    return isinstance(v, (int, float))
-
-
-class _Operand:
-    """Wraps an image operand, providing standard operators"""
-
-    def __init__(self, im):
-        self.im = im
-
-    def __fixup(self, im1):
-        # convert image to suitable mode
-        if isinstance(im1, _Operand):
-            # argument was an image.
-            if im1.im.mode in ("1", "L"):
-                return im1.im.convert("I")
-            elif im1.im.mode in ("I", "F"):
-                return im1.im
-            else:
-                raise ValueError(f"unsupported mode: {im1.im.mode}")
-        else:
-            # argument was a constant
-            if _isconstant(im1) and self.im.mode in ("1", "L", "I"):
-                return Image.new("I", self.im.size, im1)
-            else:
-                return Image.new("F", self.im.size, im1)
-
-    def apply(self, op, im1, im2=None, mode=None):
-        im1 = self.__fixup(im1)
-        if im2 is None:
-            # unary operation
-            out = Image.new(mode or im1.mode, im1.size, None)
-            im1.load()
-            try:
-                op = getattr(_imagingmath, op + "_" + im1.mode)
-            except AttributeError as e:
-                raise TypeError(f"bad operand type for '{op}'") from e
-            _imagingmath.unop(op, out.im.id, im1.im.id)
-        else:
-            # binary operation
-            im2 = self.__fixup(im2)
-            if im1.mode != im2.mode:
-                # convert both arguments to floating point
-                if im1.mode != "F":
-                    im1 = im1.convert("F")
-                if im2.mode != "F":
-                    im2 = im2.convert("F")
-            if im1.size != im2.size:
-                # crop both arguments to a common size
-                size = (min(im1.size[0], im2.size[0]), min(im1.size[1], im2.size[1]))
-                if im1.size != size:
-                    im1 = im1.crop((0, 0) + size)
-                if im2.size != size:
-                    im2 = im2.crop((0, 0) + size)
-            out = Image.new(mode or im1.mode, im1.size, None)
-            im1.load()
-            im2.load()
-            try:
-                op = getattr(_imagingmath, op + "_" + im1.mode)
-            except AttributeError as e:
-                raise TypeError(f"bad operand type for '{op}'") from e
-            _imagingmath.binop(op, out.im.id, im1.im.id, im2.im.id)
-        return _Operand(out)
-
-    # unary operators
-    def __bool__(self):
-        # an image is "true" if it contains at least one non-zero pixel
-        return self.im.getbbox() is not None
-
-    def __abs__(self):
-        return self.apply("abs", self)
-
-    def __pos__(self):
-        return self
-
-    def __neg__(self):
-        return self.apply("neg", self)
-
-    # binary operators
-    def __add__(self, other):
-        return self.apply("add", self, other)
-
-    def __radd__(self, other):
-        return self.apply("add", other, self)
-
-    def __sub__(self, other):
-        return self.apply("sub", self, other)
-
-    def __rsub__(self, other):
-        return self.apply("sub", other, self)
-
-    def __mul__(self, other):
-        return self.apply("mul", self, other)
-
-    def __rmul__(self, other):
-        return self.apply("mul", other, self)
-
-    def __truediv__(self, other):
-        return self.apply("div", self, other)
-
-    def __rtruediv__(self, other):
-        return self.apply("div", other, self)
-
-    def __mod__(self, other):
-        return self.apply("mod", self, other)
-
-    def __rmod__(self, other):
-        return self.apply("mod", other, self)
-
-    def __pow__(self, other):
-        return self.apply("pow", self, other)
-
-    def __rpow__(self, other):
-        return self.apply("pow", other, self)
-
-    # bitwise
-    def __invert__(self):
-        return self.apply("invert", self)
-
-    def __and__(self, other):
-        return self.apply("and", self, other)
-
-    def __rand__(self, other):
-        return self.apply("and", other, self)
-
-    def __or__(self, other):
-        return self.apply("or", self, other)
-
-    def __ror__(self, other):
-        return self.apply("or", other, self)
-
-    def __xor__(self, other):
-        return self.apply("xor", self, other)
-
-    def __rxor__(self, other):
-        return self.apply("xor", other, self)
-
-    def __lshift__(self, other):
-        return self.apply("lshift", self, other)
-
-    def __rshift__(self, other):
-        return self.apply("rshift", self, other)
-
-    # logical
-    def __eq__(self, other):
-        return self.apply("eq", self, other)
-
-    def __ne__(self, other):
-        return self.apply("ne", self, other)
-
-    def __lt__(self, other):
-        return self.apply("lt", self, other)
-
-    def __le__(self, other):
-        return self.apply("le", self, other)
-
-    def __gt__(self, other):
-        return self.apply("gt", self, other)
-
-    def __ge__(self, other):
-        return self.apply("ge", self, other)
-
-
-# conversions
-def imagemath_int(self):
-    return _Operand(self.im.convert("I"))
-
-
-def imagemath_float(self):
-    return _Operand(self.im.convert("F"))
-
-
-# logical
-def imagemath_equal(self, other):
-    return self.apply("eq", self, other, mode="I")
-
-
-def imagemath_notequal(self, other):
-    return self.apply("ne", self, other, mode="I")
-
-
-def imagemath_min(self, other):
-    return self.apply("min", self, other)
-
-
-def imagemath_max(self, other):
-    return self.apply("max", self, other)
-
-
-def imagemath_convert(self, mode):
-    return _Operand(self.im.convert(mode))
-
-
-ops = {}
-for k, v in list(globals().items()):
-    if k[:10] == "imagemath_":
-        ops[k[10:]] = v
-
-
-def eval(expression, _dict={}, **kw):
-    """
-    Evaluates an image expression.
-
-    :param expression: A string containing a Python-style expression.
-    :param options: Values to add to the evaluation context.  You
-                    can either use a dictionary, or one or more keyword
-                    arguments.
-    :return: The evaluated expression. This is usually an image object, but can
-             also be an integer, a floating point value, or a pixel tuple,
-             depending on the expression.
-    """
-
-    # build execution namespace
-    args = ops.copy()
-    args.update(_dict)
-    args.update(kw)
-    for k, v in list(args.items()):
-        if hasattr(v, "im"):
-            args[k] = _Operand(v)
-
-    compiled_code = compile(expression, "<string>", "eval")
-
-    def scan(code):
-        for const in code.co_consts:
-            if type(const) == type(compiled_code):
-                scan(const)
-
-        for name in code.co_names:
-            if name not in args and name != "abs":
-                raise ValueError(f"'{name}' not allowed")
-
-    scan(compiled_code)
-    out = builtins.eval(expression, {"__builtins": {"abs": abs}}, args)
-    try:
-        return out.im
-    except AttributeError:
-        return out

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageMode.py

@@ -1,91 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# standard mode descriptors
-#
-# History:
-# 2006-03-20 fl   Added
-#
-# Copyright (c) 2006 by Secret Labs AB.
-# Copyright (c) 2006 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import sys
-
-# mode descriptor cache
-_modes = None
-
-
-class ModeDescriptor:
-    """Wrapper for mode strings."""
-
-    def __init__(self, mode, bands, basemode, basetype, typestr):
-        self.mode = mode
-        self.bands = bands
-        self.basemode = basemode
-        self.basetype = basetype
-        self.typestr = typestr
-
-    def __str__(self):
-        return self.mode
-
-
-def getmode(mode):
-    """Gets a mode descriptor for the given mode."""
-    global _modes
-    if not _modes:
-        # initialize mode cache
-        modes = {}
-        endian = "<" if sys.byteorder == "little" else ">"
-        for m, (basemode, basetype, bands, typestr) in {
-            # core modes
-            # Bits need to be extended to bytes
-            "1": ("L", "L", ("1",), "|b1"),
-            "L": ("L", "L", ("L",), "|u1"),
-            "I": ("L", "I", ("I",), endian + "i4"),
-            "F": ("L", "F", ("F",), endian + "f4"),
-            "P": ("P", "L", ("P",), "|u1"),
-            "RGB": ("RGB", "L", ("R", "G", "B"), "|u1"),
-            "RGBX": ("RGB", "L", ("R", "G", "B", "X"), "|u1"),
-            "RGBA": ("RGB", "L", ("R", "G", "B", "A"), "|u1"),
-            "CMYK": ("RGB", "L", ("C", "M", "Y", "K"), "|u1"),
-            "YCbCr": ("RGB", "L", ("Y", "Cb", "Cr"), "|u1"),
-            # UNDONE - unsigned |u1i1i1
-            "LAB": ("RGB", "L", ("L", "A", "B"), "|u1"),
-            "HSV": ("RGB", "L", ("H", "S", "V"), "|u1"),
-            # extra experimental modes
-            "RGBa": ("RGB", "L", ("R", "G", "B", "a"), "|u1"),
-            "BGR;15": ("RGB", "L", ("B", "G", "R"), endian + "u2"),
-            "BGR;16": ("RGB", "L", ("B", "G", "R"), endian + "u2"),
-            "BGR;24": ("RGB", "L", ("B", "G", "R"), endian + "u3"),
-            "BGR;32": ("RGB", "L", ("B", "G", "R"), endian + "u4"),
-            "LA": ("L", "L", ("L", "A"), "|u1"),
-            "La": ("L", "L", ("L", "a"), "|u1"),
-            "PA": ("RGB", "L", ("P", "A"), "|u1"),
-        }.items():
-            modes[m] = ModeDescriptor(m, bands, basemode, basetype, typestr)
-        # mapping modes
-        for i16mode, typestr in {
-            # I;16 == I;16L, and I;32 == I;32L
-            "I;16": "<u2",
-            "I;16S": "<i2",
-            "I;16L": "<u2",
-            "I;16LS": "<i2",
-            "I;16B": ">u2",
-            "I;16BS": ">i2",
-            "I;16N": endian + "u2",
-            "I;16NS": endian + "i2",
-            "I;32": "<u4",
-            "I;32B": ">u4",
-            "I;32L": "<u4",
-            "I;32S": "<i4",
-            "I;32BS": ">i4",
-            "I;32LS": "<i4",
-        }.items():
-            modes[i16mode] = ModeDescriptor(i16mode, ("I",), "L", "L", typestr)
-        # set global mode cache atomically
-        _modes = modes
-    return _modes[mode]

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageMorph.py

@@ -1,245 +0,0 @@
-# A binary morphology add-on for the Python Imaging Library
-#
-# History:
-#   2014-06-04 Initial version.
-#
-# Copyright (c) 2014 Dov Grobgeld <dov.grobgeld@gmail.com>
-
-import re
-
-from . import Image, _imagingmorph
-
-LUT_SIZE = 1 << 9
-
-# fmt: off
-ROTATION_MATRIX = [
-    6, 3, 0,
-    7, 4, 1,
-    8, 5, 2,
-]
-MIRROR_MATRIX = [
-    2, 1, 0,
-    5, 4, 3,
-    8, 7, 6,
-]
-# fmt: on
-
-
-class LutBuilder:
-    """A class for building a MorphLut from a descriptive language
-
-    The input patterns is a list of a strings sequences like these::
-
-        4:(...
-           .1.
-           111)->1
-
-    (whitespaces including linebreaks are ignored). The option 4
-    describes a series of symmetry operations (in this case a
-    4-rotation), the pattern is described by:
-
-    - . or X - Ignore
-    - 1 - Pixel is on
-    - 0 - Pixel is off
-
-    The result of the operation is described after "->" string.
-
-    The default is to return the current pixel value, which is
-    returned if no other match is found.
-
-    Operations:
-
-    - 4 - 4 way rotation
-    - N - Negate
-    - 1 - Dummy op for no other operation (an op must always be given)
-    - M - Mirroring
-
-    Example::
-
-        lb = LutBuilder(patterns = ["4:(... .1. 111)->1"])
-        lut = lb.build_lut()
-
-    """
-
-    def __init__(self, patterns=None, op_name=None):
-        if patterns is not None:
-            self.patterns = patterns
-        else:
-            self.patterns = []
-        self.lut = None
-        if op_name is not None:
-            known_patterns = {
-                "corner": ["1:(... ... ...)->0", "4:(00. 01. ...)->1"],
-                "dilation4": ["4:(... .0. .1.)->1"],
-                "dilation8": ["4:(... .0. .1.)->1", "4:(... .0. ..1)->1"],
-                "erosion4": ["4:(... .1. .0.)->0"],
-                "erosion8": ["4:(... .1. .0.)->0", "4:(... .1. ..0)->0"],
-                "edge": [
-                    "1:(... ... ...)->0",
-                    "4:(.0. .1. ...)->1",
-                    "4:(01. .1. ...)->1",
-                ],
-            }
-            if op_name not in known_patterns:
-                raise Exception("Unknown pattern " + op_name + "!")
-
-            self.patterns = known_patterns[op_name]
-
-    def add_patterns(self, patterns):
-        self.patterns += patterns
-
-    def build_default_lut(self):
-        symbols = [0, 1]
-        m = 1 << 4  # pos of current pixel
-        self.lut = bytearray(symbols[(i & m) > 0] for i in range(LUT_SIZE))
-
-    def get_lut(self):
-        return self.lut
-
-    def _string_permute(self, pattern, permutation):
-        """string_permute takes a pattern and a permutation and returns the
-        string permuted according to the permutation list.
-        """
-        assert len(permutation) == 9
-        return "".join(pattern[p] for p in permutation)
-
-    def _pattern_permute(self, basic_pattern, options, basic_result):
-        """pattern_permute takes a basic pattern and its result and clones
-        the pattern according to the modifications described in the $options
-        parameter. It returns a list of all cloned patterns."""
-        patterns = [(basic_pattern, basic_result)]
-
-        # rotations
-        if "4" in options:
-            res = patterns[-1][1]
-            for i in range(4):
-                patterns.append(
-                    (self._string_permute(patterns[-1][0], ROTATION_MATRIX), res)
-                )
-        # mirror
-        if "M" in options:
-            n = len(patterns)
-            for pattern, res in patterns[:n]:
-                patterns.append((self._string_permute(pattern, MIRROR_MATRIX), res))
-
-        # negate
-        if "N" in options:
-            n = len(patterns)
-            for pattern, res in patterns[:n]:
-                # Swap 0 and 1
-                pattern = pattern.replace("0", "Z").replace("1", "0").replace("Z", "1")
-                res = 1 - int(res)
-                patterns.append((pattern, res))
-
-        return patterns
-
-    def build_lut(self):
-        """Compile all patterns into a morphology lut.
-
-        TBD :Build based on (file) morphlut:modify_lut
-        """
-        self.build_default_lut()
-        patterns = []
-
-        # Parse and create symmetries of the patterns strings
-        for p in self.patterns:
-            m = re.search(r"(\w*):?\s*\((.+?)\)\s*->\s*(\d)", p.replace("\n", ""))
-            if not m:
-                raise Exception('Syntax error in pattern "' + p + '"')
-            options = m.group(1)
-            pattern = m.group(2)
-            result = int(m.group(3))
-
-            # Get rid of spaces
-            pattern = pattern.replace(" ", "").replace("\n", "")
-
-            patterns += self._pattern_permute(pattern, options, result)
-
-        # compile the patterns into regular expressions for speed
-        for i, pattern in enumerate(patterns):
-            p = pattern[0].replace(".", "X").replace("X", "[01]")
-            p = re.compile(p)
-            patterns[i] = (p, pattern[1])
-
-        # Step through table and find patterns that match.
-        # Note that all the patterns are searched. The last one
-        # caught overrides
-        for i in range(LUT_SIZE):
-            # Build the bit pattern
-            bitpattern = bin(i)[2:]
-            bitpattern = ("0" * (9 - len(bitpattern)) + bitpattern)[::-1]
-
-            for p, r in patterns:
-                if p.match(bitpattern):
-                    self.lut[i] = [0, 1][r]
-
-        return self.lut
-
-
-class MorphOp:
-    """A class for binary morphological operators"""
-
-    def __init__(self, lut=None, op_name=None, patterns=None):
-        """Create a binary morphological operator"""
-        self.lut = lut
-        if op_name is not None:
-            self.lut = LutBuilder(op_name=op_name).build_lut()
-        elif patterns is not None:
-            self.lut = LutBuilder(patterns=patterns).build_lut()
-
-    def apply(self, image):
-        """Run a single morphological operation on an image
-
-        Returns a tuple of the number of changed pixels and the
-        morphed image"""
-        if self.lut is None:
-            raise Exception("No operator loaded")
-
-        if image.mode != "L":
-            raise ValueError("Image mode must be L")
-        outimage = Image.new(image.mode, image.size, None)
-        count = _imagingmorph.apply(bytes(self.lut), image.im.id, outimage.im.id)
-        return count, outimage
-
-    def match(self, image):
-        """Get a list of coordinates matching the morphological operation on
-        an image.
-
-        Returns a list of tuples of (x,y) coordinates
-        of all matching pixels. See :ref:`coordinate-system`."""
-        if self.lut is None:
-            raise Exception("No operator loaded")
-
-        if image.mode != "L":
-            raise ValueError("Image mode must be L")
-        return _imagingmorph.match(bytes(self.lut), image.im.id)
-
-    def get_on_pixels(self, image):
-        """Get a list of all turned on pixels in a binary image
-
-        Returns a list of tuples of (x,y) coordinates
-        of all matching pixels. See :ref:`coordinate-system`."""
-
-        if image.mode != "L":
-            raise ValueError("Image mode must be L")
-        return _imagingmorph.get_on_pixels(image.im.id)
-
-    def load_lut(self, filename):
-        """Load an operator from an mrl file"""
-        with open(filename, "rb") as f:
-            self.lut = bytearray(f.read())
-
-        if len(self.lut) != LUT_SIZE:
-            self.lut = None
-            raise Exception("Wrong size operator file!")
-
-    def save_lut(self, filename):
-        """Save an operator to an mrl file"""
-        if self.lut is None:
-            raise Exception("No operator loaded")
-        with open(filename, "wb") as f:
-            f.write(self.lut)
-
-    def set_lut(self, lut):
-        """Set the lut from an external source"""
-        self.lut = lut

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageOps.py

@@ -1,616 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# standard image operations
-#
-# History:
-# 2001-10-20 fl   Created
-# 2001-10-23 fl   Added autocontrast operator
-# 2001-12-18 fl   Added Kevin's fit operator
-# 2004-03-14 fl   Fixed potential division by zero in equalize
-# 2005-05-05 fl   Fixed equalize for low number of values
-#
-# Copyright (c) 2001-2004 by Secret Labs AB
-# Copyright (c) 2001-2004 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import functools
-import operator
-import re
-
-from . import Image, ImagePalette
-
-#
-# helpers
-
-
-def _border(border):
-    if isinstance(border, tuple):
-        if len(border) == 2:
-            left, top = right, bottom = border
-        elif len(border) == 4:
-            left, top, right, bottom = border
-    else:
-        left = top = right = bottom = border
-    return left, top, right, bottom
-
-
-def _color(color, mode):
-    if isinstance(color, str):
-        from . import ImageColor
-
-        color = ImageColor.getcolor(color, mode)
-    return color
-
-
-def _lut(image, lut):
-    if image.mode == "P":
-        # FIXME: apply to lookup table, not image data
-        raise NotImplementedError("mode P support coming soon")
-    elif image.mode in ("L", "RGB"):
-        if image.mode == "RGB" and len(lut) == 256:
-            lut = lut + lut + lut
-        return image.point(lut)
-    else:
-        raise OSError("not supported for this image mode")
-
-
-#
-# actions
-
-
-def autocontrast(image, cutoff=0, ignore=None, mask=None, preserve_tone=False):
-    """
-    Maximize (normalize) image contrast. This function calculates a
-    histogram of the input image (or mask region), removes ``cutoff`` percent of the
-    lightest and darkest pixels from the histogram, and remaps the image
-    so that the darkest pixel becomes black (0), and the lightest
-    becomes white (255).
-
-    :param image: The image to process.
-    :param cutoff: The percent to cut off from the histogram on the low and
-                   high ends. Either a tuple of (low, high), or a single
-                   number for both.
-    :param ignore: The background pixel value (use None for no background).
-    :param mask: Histogram used in contrast operation is computed using pixels
-                 within the mask. If no mask is given the entire image is used
-                 for histogram computation.
-    :param preserve_tone: Preserve image tone in Photoshop-like style autocontrast.
-
-                          .. versionadded:: 8.2.0
-
-    :return: An image.
-    """
-    if preserve_tone:
-        histogram = image.convert("L").histogram(mask)
-    else:
-        histogram = image.histogram(mask)
-
-    lut = []
-    for layer in range(0, len(histogram), 256):
-        h = histogram[layer : layer + 256]
-        if ignore is not None:
-            # get rid of outliers
-            try:
-                h[ignore] = 0
-            except TypeError:
-                # assume sequence
-                for ix in ignore:
-                    h[ix] = 0
-        if cutoff:
-            # cut off pixels from both ends of the histogram
-            if not isinstance(cutoff, tuple):
-                cutoff = (cutoff, cutoff)
-            # get number of pixels
-            n = 0
-            for ix in range(256):
-                n = n + h[ix]
-            # remove cutoff% pixels from the low end
-            cut = n * cutoff[0] // 100
-            for lo in range(256):
-                if cut > h[lo]:
-                    cut = cut - h[lo]
-                    h[lo] = 0
-                else:
-                    h[lo] -= cut
-                    cut = 0
-                if cut <= 0:
-                    break
-            # remove cutoff% samples from the high end
-            cut = n * cutoff[1] // 100
-            for hi in range(255, -1, -1):
-                if cut > h[hi]:
-                    cut = cut - h[hi]
-                    h[hi] = 0
-                else:
-                    h[hi] -= cut
-                    cut = 0
-                if cut <= 0:
-                    break
-        # find lowest/highest samples after preprocessing
-        for lo in range(256):
-            if h[lo]:
-                break
-        for hi in range(255, -1, -1):
-            if h[hi]:
-                break
-        if hi <= lo:
-            # don't bother
-            lut.extend(list(range(256)))
-        else:
-            scale = 255.0 / (hi - lo)
-            offset = -lo * scale
-            for ix in range(256):
-                ix = int(ix * scale + offset)
-                if ix < 0:
-                    ix = 0
-                elif ix > 255:
-                    ix = 255
-                lut.append(ix)
-    return _lut(image, lut)
-
-
-def colorize(image, black, white, mid=None, blackpoint=0, whitepoint=255, midpoint=127):
-    """
-    Colorize grayscale image.
-    This function calculates a color wedge which maps all black pixels in
-    the source image to the first color and all white pixels to the
-    second color. If ``mid`` is specified, it uses three-color mapping.
-    The ``black`` and ``white`` arguments should be RGB tuples or color names;
-    optionally you can use three-color mapping by also specifying ``mid``.
-    Mapping positions for any of the colors can be specified
-    (e.g. ``blackpoint``), where these parameters are the integer
-    value corresponding to where the corresponding color should be mapped.
-    These parameters must have logical order, such that
-    ``blackpoint <= midpoint <= whitepoint`` (if ``mid`` is specified).
-
-    :param image: The image to colorize.
-    :param black: The color to use for black input pixels.
-    :param white: The color to use for white input pixels.
-    :param mid: The color to use for midtone input pixels.
-    :param blackpoint: an int value [0, 255] for the black mapping.
-    :param whitepoint: an int value [0, 255] for the white mapping.
-    :param midpoint: an int value [0, 255] for the midtone mapping.
-    :return: An image.
-    """
-
-    # Initial asserts
-    assert image.mode == "L"
-    if mid is None:
-        assert 0 <= blackpoint <= whitepoint <= 255
-    else:
-        assert 0 <= blackpoint <= midpoint <= whitepoint <= 255
-
-    # Define colors from arguments
-    black = _color(black, "RGB")
-    white = _color(white, "RGB")
-    if mid is not None:
-        mid = _color(mid, "RGB")
-
-    # Empty lists for the mapping
-    red = []
-    green = []
-    blue = []
-
-    # Create the low-end values
-    for i in range(0, blackpoint):
-        red.append(black[0])
-        green.append(black[1])
-        blue.append(black[2])
-
-    # Create the mapping (2-color)
-    if mid is None:
-
-        range_map = range(0, whitepoint - blackpoint)
-
-        for i in range_map:
-            red.append(black[0] + i * (white[0] - black[0]) // len(range_map))
-            green.append(black[1] + i * (white[1] - black[1]) // len(range_map))
-            blue.append(black[2] + i * (white[2] - black[2]) // len(range_map))
-
-    # Create the mapping (3-color)
-    else:
-
-        range_map1 = range(0, midpoint - blackpoint)
-        range_map2 = range(0, whitepoint - midpoint)
-
-        for i in range_map1:
-            red.append(black[0] + i * (mid[0] - black[0]) // len(range_map1))
-            green.append(black[1] + i * (mid[1] - black[1]) // len(range_map1))
-            blue.append(black[2] + i * (mid[2] - black[2]) // len(range_map1))
-        for i in range_map2:
-            red.append(mid[0] + i * (white[0] - mid[0]) // len(range_map2))
-            green.append(mid[1] + i * (white[1] - mid[1]) // len(range_map2))
-            blue.append(mid[2] + i * (white[2] - mid[2]) // len(range_map2))
-
-    # Create the high-end values
-    for i in range(0, 256 - whitepoint):
-        red.append(white[0])
-        green.append(white[1])
-        blue.append(white[2])
-
-    # Return converted image
-    image = image.convert("RGB")
-    return _lut(image, red + green + blue)
-
-
-def contain(image, size, method=Image.Resampling.BICUBIC):
-    """
-    Returns a resized version of the image, set to the maximum width and height
-    within the requested size, while maintaining the original aspect ratio.
-
-    :param image: The image to resize and crop.
-    :param size: The requested output size in pixels, given as a
-                 (width, height) tuple.
-    :param method: Resampling method to use. Default is
-                   :py:attr:`PIL.Image.BICUBIC`. See :ref:`concept-filters`.
-    :return: An image.
-    """
-
-    im_ratio = image.width / image.height
-    dest_ratio = size[0] / size[1]
-
-    if im_ratio != dest_ratio:
-        if im_ratio > dest_ratio:
-            new_height = round(image.height / image.width * size[0])
-            if new_height != size[1]:
-                size = (size[0], new_height)
-        else:
-            new_width = round(image.width / image.height * size[1])
-            if new_width != size[0]:
-                size = (new_width, size[1])
-    return image.resize(size, resample=method)
-
-
-def pad(image, size, method=Image.Resampling.BICUBIC, color=None, centering=(0.5, 0.5)):
-    """
-    Returns a resized and padded version of the image, expanded to fill the
-    requested aspect ratio and size.
-
-    :param image: The image to resize and crop.
-    :param size: The requested output size in pixels, given as a
-                 (width, height) tuple.
-    :param method: Resampling method to use. Default is
-                   :py:attr:`PIL.Image.BICUBIC`. See :ref:`concept-filters`.
-    :param color: The background color of the padded image.
-    :param centering: Control the position of the original image within the
-                      padded version.
-
-                          (0.5, 0.5) will keep the image centered
-                          (0, 0) will keep the image aligned to the top left
-                          (1, 1) will keep the image aligned to the bottom
-                          right
-    :return: An image.
-    """
-
-    resized = contain(image, size, method)
-    if resized.size == size:
-        out = resized
-    else:
-        out = Image.new(image.mode, size, color)
-        if resized.palette:
-            out.putpalette(resized.getpalette())
-        if resized.width != size[0]:
-            x = round((size[0] - resized.width) * max(0, min(centering[0], 1)))
-            out.paste(resized, (x, 0))
-        else:
-            y = round((size[1] - resized.height) * max(0, min(centering[1], 1)))
-            out.paste(resized, (0, y))
-    return out
-
-
-def crop(image, border=0):
-    """
-    Remove border from image.  The same amount of pixels are removed
-    from all four sides.  This function works on all image modes.
-
-    .. seealso:: :py:meth:`~PIL.Image.Image.crop`
-
-    :param image: The image to crop.
-    :param border: The number of pixels to remove.
-    :return: An image.
-    """
-    left, top, right, bottom = _border(border)
-    return image.crop((left, top, image.size[0] - right, image.size[1] - bottom))
-
-
-def scale(image, factor, resample=Image.Resampling.BICUBIC):
-    """
-    Returns a rescaled image by a specific factor given in parameter.
-    A factor greater than 1 expands the image, between 0 and 1 contracts the
-    image.
-
-    :param image: The image to rescale.
-    :param factor: The expansion factor, as a float.
-    :param resample: Resampling method to use. Default is
-                     :py:attr:`PIL.Image.BICUBIC`. See :ref:`concept-filters`.
-    :returns: An :py:class:`~PIL.Image.Image` object.
-    """
-    if factor == 1:
-        return image.copy()
-    elif factor <= 0:
-        raise ValueError("the factor must be greater than 0")
-    else:
-        size = (round(factor * image.width), round(factor * image.height))
-        return image.resize(size, resample)
-
-
-def deform(image, deformer, resample=Image.Resampling.BILINEAR):
-    """
-    Deform the image.
-
-    :param image: The image to deform.
-    :param deformer: A deformer object.  Any object that implements a
-                    ``getmesh`` method can be used.
-    :param resample: An optional resampling filter. Same values possible as
-       in the PIL.Image.transform function.
-    :return: An image.
-    """
-    return image.transform(
-        image.size, Image.Transform.MESH, deformer.getmesh(image), resample
-    )
-
-
-def equalize(image, mask=None):
-    """
-    Equalize the image histogram. This function applies a non-linear
-    mapping to the input image, in order to create a uniform
-    distribution of grayscale values in the output image.
-
-    :param image: The image to equalize.
-    :param mask: An optional mask.  If given, only the pixels selected by
-                 the mask are included in the analysis.
-    :return: An image.
-    """
-    if image.mode == "P":
-        image = image.convert("RGB")
-    h = image.histogram(mask)
-    lut = []
-    for b in range(0, len(h), 256):
-        histo = [_f for _f in h[b : b + 256] if _f]
-        if len(histo) <= 1:
-            lut.extend(list(range(256)))
-        else:
-            step = (functools.reduce(operator.add, histo) - histo[-1]) // 255
-            if not step:
-                lut.extend(list(range(256)))
-            else:
-                n = step // 2
-                for i in range(256):
-                    lut.append(n // step)
-                    n = n + h[i + b]
-    return _lut(image, lut)
-
-
-def expand(image, border=0, fill=0):
-    """
-    Add border to the image
-
-    :param image: The image to expand.
-    :param border: Border width, in pixels.
-    :param fill: Pixel fill value (a color value).  Default is 0 (black).
-    :return: An image.
-    """
-    left, top, right, bottom = _border(border)
-    width = left + image.size[0] + right
-    height = top + image.size[1] + bottom
-    color = _color(fill, image.mode)
-    if image.palette:
-        palette = ImagePalette.ImagePalette(palette=image.getpalette())
-        if isinstance(color, tuple):
-            color = palette.getcolor(color)
-    else:
-        palette = None
-    out = Image.new(image.mode, (width, height), color)
-    if palette:
-        out.putpalette(palette.palette)
-    out.paste(image, (left, top))
-    return out
-
-
-def fit(image, size, method=Image.Resampling.BICUBIC, bleed=0.0, centering=(0.5, 0.5)):
-    """
-    Returns a resized and cropped version of the image, cropped to the
-    requested aspect ratio and size.
-
-    This function was contributed by Kevin Cazabon.
-
-    :param image: The image to resize and crop.
-    :param size: The requested output size in pixels, given as a
-                 (width, height) tuple.
-    :param method: Resampling method to use. Default is
-                   :py:attr:`PIL.Image.BICUBIC`. See :ref:`concept-filters`.
-    :param bleed: Remove a border around the outside of the image from all
-                  four edges. The value is a decimal percentage (use 0.01 for
-                  one percent). The default value is 0 (no border).
-                  Cannot be greater than or equal to 0.5.
-    :param centering: Control the cropping position.  Use (0.5, 0.5) for
-                      center cropping (e.g. if cropping the width, take 50% off
-                      of the left side, and therefore 50% off the right side).
-                      (0.0, 0.0) will crop from the top left corner (i.e. if
-                      cropping the width, take all of the crop off of the right
-                      side, and if cropping the height, take all of it off the
-                      bottom).  (1.0, 0.0) will crop from the bottom left
-                      corner, etc. (i.e. if cropping the width, take all of the
-                      crop off the left side, and if cropping the height take
-                      none from the top, and therefore all off the bottom).
-    :return: An image.
-    """
-
-    # by Kevin Cazabon, Feb 17/2000
-    # kevin@cazabon.com
-    # https://www.cazabon.com
-
-    # ensure centering is mutable
-    centering = list(centering)
-
-    if not 0.0 <= centering[0] <= 1.0:
-        centering[0] = 0.5
-    if not 0.0 <= centering[1] <= 1.0:
-        centering[1] = 0.5
-
-    if not 0.0 <= bleed < 0.5:
-        bleed = 0.0
-
-    # calculate the area to use for resizing and cropping, subtracting
-    # the 'bleed' around the edges
-
-    # number of pixels to trim off on Top and Bottom, Left and Right
-    bleed_pixels = (bleed * image.size[0], bleed * image.size[1])
-
-    live_size = (
-        image.size[0] - bleed_pixels[0] * 2,
-        image.size[1] - bleed_pixels[1] * 2,
-    )
-
-    # calculate the aspect ratio of the live_size
-    live_size_ratio = live_size[0] / live_size[1]
-
-    # calculate the aspect ratio of the output image
-    output_ratio = size[0] / size[1]
-
-    # figure out if the sides or top/bottom will be cropped off
-    if live_size_ratio == output_ratio:
-        # live_size is already the needed ratio
-        crop_width = live_size[0]
-        crop_height = live_size[1]
-    elif live_size_ratio >= output_ratio:
-        # live_size is wider than what's needed, crop the sides
-        crop_width = output_ratio * live_size[1]
-        crop_height = live_size[1]
-    else:
-        # live_size is taller than what's needed, crop the top and bottom
-        crop_width = live_size[0]
-        crop_height = live_size[0] / output_ratio
-
-    # make the crop
-    crop_left = bleed_pixels[0] + (live_size[0] - crop_width) * centering[0]
-    crop_top = bleed_pixels[1] + (live_size[1] - crop_height) * centering[1]
-
-    crop = (crop_left, crop_top, crop_left + crop_width, crop_top + crop_height)
-
-    # resize the image and return it
-    return image.resize(size, method, box=crop)
-
-
-def flip(image):
-    """
-    Flip the image vertically (top to bottom).
-
-    :param image: The image to flip.
-    :return: An image.
-    """
-    return image.transpose(Image.Transpose.FLIP_TOP_BOTTOM)
-
-
-def grayscale(image):
-    """
-    Convert the image to grayscale.
-
-    :param image: The image to convert.
-    :return: An image.
-    """
-    return image.convert("L")
-
-
-def invert(image):
-    """
-    Invert (negate) the image.
-
-    :param image: The image to invert.
-    :return: An image.
-    """
-    lut = []
-    for i in range(256):
-        lut.append(255 - i)
-    return image.point(lut) if image.mode == "1" else _lut(image, lut)
-
-
-def mirror(image):
-    """
-    Flip image horizontally (left to right).
-
-    :param image: The image to mirror.
-    :return: An image.
-    """
-    return image.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
-
-
-def posterize(image, bits):
-    """
-    Reduce the number of bits for each color channel.
-
-    :param image: The image to posterize.
-    :param bits: The number of bits to keep for each channel (1-8).
-    :return: An image.
-    """
-    lut = []
-    mask = ~(2 ** (8 - bits) - 1)
-    for i in range(256):
-        lut.append(i & mask)
-    return _lut(image, lut)
-
-
-def solarize(image, threshold=128):
-    """
-    Invert all pixel values above a threshold.
-
-    :param image: The image to solarize.
-    :param threshold: All pixels above this greyscale level are inverted.
-    :return: An image.
-    """
-    lut = []
-    for i in range(256):
-        if i < threshold:
-            lut.append(i)
-        else:
-            lut.append(255 - i)
-    return _lut(image, lut)
-
-
-def exif_transpose(image):
-    """
-    If an image has an EXIF Orientation tag, other than 1, return a new image
-    that is transposed accordingly. The new image will have the orientation
-    data removed.
-
-    Otherwise, return a copy of the image.
-
-    :param image: The image to transpose.
-    :return: An image.
-    """
-    exif = image.getexif()
-    orientation = exif.get(0x0112)
-    method = {
-        2: Image.Transpose.FLIP_LEFT_RIGHT,
-        3: Image.Transpose.ROTATE_180,
-        4: Image.Transpose.FLIP_TOP_BOTTOM,
-        5: Image.Transpose.TRANSPOSE,
-        6: Image.Transpose.ROTATE_270,
-        7: Image.Transpose.TRANSVERSE,
-        8: Image.Transpose.ROTATE_90,
-    }.get(orientation)
-    if method is not None:
-        transposed_image = image.transpose(method)
-        transposed_exif = transposed_image.getexif()
-        if 0x0112 in transposed_exif:
-            del transposed_exif[0x0112]
-            if "exif" in transposed_image.info:
-                transposed_image.info["exif"] = transposed_exif.tobytes()
-            elif "Raw profile type exif" in transposed_image.info:
-                transposed_image.info[
-                    "Raw profile type exif"
-                ] = transposed_exif.tobytes().hex()
-            elif "XML:com.adobe.xmp" in transposed_image.info:
-                for pattern in (
-                    r'tiff:Orientation="([0-9])"',
-                    r"<tiff:Orientation>([0-9])</tiff:Orientation>",
-                ):
-                    transposed_image.info["XML:com.adobe.xmp"] = re.sub(
-                        pattern, "", transposed_image.info["XML:com.adobe.xmp"]
-                    )
-        return transposed_image
-    return image.copy()

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImagePalette.py

@@ -1,268 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# image palette object
-#
-# History:
-# 1996-03-11 fl   Rewritten.
-# 1997-01-03 fl   Up and running.
-# 1997-08-23 fl   Added load hack
-# 2001-04-16 fl   Fixed randint shadow bug in random()
-#
-# Copyright (c) 1997-2001 by Secret Labs AB
-# Copyright (c) 1996-1997 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import array
-
-from . import GimpGradientFile, GimpPaletteFile, ImageColor, PaletteFile
-from ._deprecate import deprecate
-
-
-class ImagePalette:
-    """
-    Color palette for palette mapped images
-
-    :param mode: The mode to use for the palette. See:
-        :ref:`concept-modes`. Defaults to "RGB"
-    :param palette: An optional palette. If given, it must be a bytearray,
-        an array or a list of ints between 0-255. The list must consist of
-        all channels for one color followed by the next color (e.g. RGBRGBRGB).
-        Defaults to an empty palette.
-    """
-
-    def __init__(self, mode="RGB", palette=None, size=0):
-        self.mode = mode
-        self.rawmode = None  # if set, palette contains raw data
-        self.palette = palette or bytearray()
-        self.dirty = None
-        if size != 0:
-            deprecate("The size parameter", 10, None)
-            if size != len(self.palette):
-                raise ValueError("wrong palette size")
-
-    @property
-    def palette(self):
-        return self._palette
-
-    @palette.setter
-    def palette(self, palette):
-        self._colors = None
-        self._palette = palette
-
-    @property
-    def colors(self):
-        if self._colors is None:
-            mode_len = len(self.mode)
-            self._colors = {}
-            for i in range(0, len(self.palette), mode_len):
-                color = tuple(self.palette[i : i + mode_len])
-                if color in self._colors:
-                    continue
-                self._colors[color] = i // mode_len
-        return self._colors
-
-    @colors.setter
-    def colors(self, colors):
-        self._colors = colors
-
-    def copy(self):
-        new = ImagePalette()
-
-        new.mode = self.mode
-        new.rawmode = self.rawmode
-        if self.palette is not None:
-            new.palette = self.palette[:]
-        new.dirty = self.dirty
-
-        return new
-
-    def getdata(self):
-        """
-        Get palette contents in format suitable for the low-level
-        ``im.putpalette`` primitive.
-
-        .. warning:: This method is experimental.
-        """
-        if self.rawmode:
-            return self.rawmode, self.palette
-        return self.mode, self.tobytes()
-
-    def tobytes(self):
-        """Convert palette to bytes.
-
-        .. warning:: This method is experimental.
-        """
-        if self.rawmode:
-            raise ValueError("palette contains raw palette data")
-        if isinstance(self.palette, bytes):
-            return self.palette
-        arr = array.array("B", self.palette)
-        return arr.tobytes()
-
-    # Declare tostring as an alias for tobytes
-    tostring = tobytes
-
-    def getcolor(self, color, image=None):
-        """Given an rgb tuple, allocate palette entry.
-
-        .. warning:: This method is experimental.
-        """
-        if self.rawmode:
-            raise ValueError("palette contains raw palette data")
-        if isinstance(color, tuple):
-            if self.mode == "RGB":
-                if len(color) == 4:
-                    if color[3] != 255:
-                        raise ValueError(
-                            "cannot add non-opaque RGBA color to RGB palette"
-                        )
-                    color = color[:3]
-            elif self.mode == "RGBA":
-                if len(color) == 3:
-                    color += (255,)
-            try:
-                return self.colors[color]
-            except KeyError as e:
-                # allocate new color slot
-                if not isinstance(self.palette, bytearray):
-                    self._palette = bytearray(self.palette)
-                index = len(self.palette) // 3
-                special_colors = ()
-                if image:
-                    special_colors = (
-                        image.info.get("background"),
-                        image.info.get("transparency"),
-                    )
-                while index in special_colors:
-                    index += 1
-                if index >= 256:
-                    if image:
-                        # Search for an unused index
-                        for i, count in reversed(list(enumerate(image.histogram()))):
-                            if count == 0 and i not in special_colors:
-                                index = i
-                                break
-                    if index >= 256:
-                        raise ValueError("cannot allocate more than 256 colors") from e
-                self.colors[color] = index
-                if index * 3 < len(self.palette):
-                    self._palette = (
-                        self.palette[: index * 3]
-                        + bytes(color)
-                        + self.palette[index * 3 + 3 :]
-                    )
-                else:
-                    self._palette += bytes(color)
-                self.dirty = 1
-                return index
-        else:
-            raise ValueError(f"unknown color specifier: {repr(color)}")
-
-    def save(self, fp):
-        """Save palette to text file.
-
-        .. warning:: This method is experimental.
-        """
-        if self.rawmode:
-            raise ValueError("palette contains raw palette data")
-        if isinstance(fp, str):
-            fp = open(fp, "w")
-        fp.write("# Palette\n")
-        fp.write(f"# Mode: {self.mode}\n")
-        for i in range(256):
-            fp.write(f"{i}")
-            for j in range(i * len(self.mode), (i + 1) * len(self.mode)):
-                try:
-                    fp.write(f" {self.palette[j]}")
-                except IndexError:
-                    fp.write(" 0")
-            fp.write("\n")
-        fp.close()
-
-
-# --------------------------------------------------------------------
-# Internal
-
-
-def raw(rawmode, data):
-    palette = ImagePalette()
-    palette.rawmode = rawmode
-    palette.palette = data
-    palette.dirty = 1
-    return palette
-
-
-# --------------------------------------------------------------------
-# Factories
-
-
-def make_linear_lut(black, white):
-    lut = []
-    if black == 0:
-        for i in range(256):
-            lut.append(white * i // 255)
-    else:
-        raise NotImplementedError  # FIXME
-    return lut
-
-
-def make_gamma_lut(exp):
-    lut = []
-    for i in range(256):
-        lut.append(int(((i / 255.0) ** exp) * 255.0 + 0.5))
-    return lut
-
-
-def negative(mode="RGB"):
-    palette = list(range(256 * len(mode)))
-    palette.reverse()
-    return ImagePalette(mode, [i // len(mode) for i in palette])
-
-
-def random(mode="RGB"):
-    from random import randint
-
-    palette = []
-    for i in range(256 * len(mode)):
-        palette.append(randint(0, 255))
-    return ImagePalette(mode, palette)
-
-
-def sepia(white="#fff0c0"):
-    bands = [make_linear_lut(0, band) for band in ImageColor.getrgb(white)]
-    return ImagePalette("RGB", [bands[i % 3][i // 3] for i in range(256 * 3)])
-
-
-def wedge(mode="RGB"):
-    palette = list(range(256 * len(mode)))
-    return ImagePalette(mode, [i // len(mode) for i in palette])
-
-
-def load(filename):
-
-    # FIXME: supports GIMP gradients only
-
-    with open(filename, "rb") as fp:
-
-        for paletteHandler in [
-            GimpPaletteFile.GimpPaletteFile,
-            GimpGradientFile.GimpGradientFile,
-            PaletteFile.PaletteFile,
-        ]:
-            try:
-                fp.seek(0)
-                lut = paletteHandler(fp).getpalette()
-                if lut:
-                    break
-            except (SyntaxError, ValueError):
-                # import traceback
-                # traceback.print_exc()
-                pass
-        else:
-            raise OSError("cannot load palette")
-
-    return lut  # data, rawmode

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImagePath.py

@@ -1,19 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# path interface
-#
-# History:
-# 1996-11-04 fl   Created
-# 2002-04-14 fl   Added documentation stub class
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996.
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image
-
-Path = Image.core.path

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageQt.py

@@ -1,228 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a simple Qt image interface.
-#
-# history:
-# 2006-06-03 fl: created
-# 2006-06-04 fl: inherit from QImage instead of wrapping it
-# 2006-06-05 fl: removed toimage helper; move string support to ImageQt
-# 2013-11-13 fl: add support for Qt5 (aurelien.ballier@cyclonit.com)
-#
-# Copyright (c) 2006 by Secret Labs AB
-# Copyright (c) 2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import sys
-from io import BytesIO
-
-from . import Image
-from ._deprecate import deprecate
-from ._util import is_path
-
-qt_versions = [
-    ["6", "PyQt6"],
-    ["side6", "PySide6"],
-    ["5", "PyQt5"],
-    ["side2", "PySide2"],
-]
-
-# If a version has already been imported, attempt it first
-qt_versions.sort(key=lambda qt_version: qt_version[1] in sys.modules, reverse=True)
-for qt_version, qt_module in qt_versions:
-    try:
-        if qt_module == "PyQt6":
-            from PyQt6.QtCore import QBuffer, QIODevice
-            from PyQt6.QtGui import QImage, QPixmap, qRgba
-        elif qt_module == "PySide6":
-            from PySide6.QtCore import QBuffer, QIODevice
-            from PySide6.QtGui import QImage, QPixmap, qRgba
-        elif qt_module == "PyQt5":
-            from PyQt5.QtCore import QBuffer, QIODevice
-            from PyQt5.QtGui import QImage, QPixmap, qRgba
-
-            deprecate("Support for PyQt5", 10, "PyQt6 or PySide6")
-        elif qt_module == "PySide2":
-            from PySide2.QtCore import QBuffer, QIODevice
-            from PySide2.QtGui import QImage, QPixmap, qRgba
-
-            deprecate("Support for PySide2", 10, "PyQt6 or PySide6")
-    except (ImportError, RuntimeError):
-        continue
-    qt_is_installed = True
-    break
-else:
-    qt_is_installed = False
-    qt_version = None
-
-
-def rgb(r, g, b, a=255):
-    """(Internal) Turns an RGB color into a Qt compatible color integer."""
-    # use qRgb to pack the colors, and then turn the resulting long
-    # into a negative integer with the same bitpattern.
-    return qRgba(r, g, b, a) & 0xFFFFFFFF
-
-
-def fromqimage(im):
-    """
-    :param im: QImage or PIL ImageQt object
-    """
-    buffer = QBuffer()
-    if qt_version == "6":
-        try:
-            qt_openmode = QIODevice.OpenModeFlag
-        except AttributeError:
-            qt_openmode = QIODevice.OpenMode
-    else:
-        qt_openmode = QIODevice
-    buffer.open(qt_openmode.ReadWrite)
-    # preserve alpha channel with png
-    # otherwise ppm is more friendly with Image.open
-    if im.hasAlphaChannel():
-        im.save(buffer, "png")
-    else:
-        im.save(buffer, "ppm")
-
-    b = BytesIO()
-    b.write(buffer.data())
-    buffer.close()
-    b.seek(0)
-
-    return Image.open(b)
-
-
-def fromqpixmap(im):
-    return fromqimage(im)
-    # buffer = QBuffer()
-    # buffer.open(QIODevice.ReadWrite)
-    # # im.save(buffer)
-    # # What if png doesn't support some image features like animation?
-    # im.save(buffer, 'ppm')
-    # bytes_io = BytesIO()
-    # bytes_io.write(buffer.data())
-    # buffer.close()
-    # bytes_io.seek(0)
-    # return Image.open(bytes_io)
-
-
-def align8to32(bytes, width, mode):
-    """
-    converts each scanline of data from 8 bit to 32 bit aligned
-    """
-
-    bits_per_pixel = {"1": 1, "L": 8, "P": 8, "I;16": 16}[mode]
-
-    # calculate bytes per line and the extra padding if needed
-    bits_per_line = bits_per_pixel * width
-    full_bytes_per_line, remaining_bits_per_line = divmod(bits_per_line, 8)
-    bytes_per_line = full_bytes_per_line + (1 if remaining_bits_per_line else 0)
-
-    extra_padding = -bytes_per_line % 4
-
-    # already 32 bit aligned by luck
-    if not extra_padding:
-        return bytes
-
-    new_data = []
-    for i in range(len(bytes) // bytes_per_line):
-        new_data.append(
-            bytes[i * bytes_per_line : (i + 1) * bytes_per_line]
-            + b"\x00" * extra_padding
-        )
-
-    return b"".join(new_data)
-
-
-def _toqclass_helper(im):
-    data = None
-    colortable = None
-    exclusive_fp = False
-
-    # handle filename, if given instead of image name
-    if hasattr(im, "toUtf8"):
-        # FIXME - is this really the best way to do this?
-        im = str(im.toUtf8(), "utf-8")
-    if is_path(im):
-        im = Image.open(im)
-        exclusive_fp = True
-
-    qt_format = QImage.Format if qt_version == "6" else QImage
-    if im.mode == "1":
-        format = qt_format.Format_Mono
-    elif im.mode == "L":
-        format = qt_format.Format_Indexed8
-        colortable = []
-        for i in range(256):
-            colortable.append(rgb(i, i, i))
-    elif im.mode == "P":
-        format = qt_format.Format_Indexed8
-        colortable = []
-        palette = im.getpalette()
-        for i in range(0, len(palette), 3):
-            colortable.append(rgb(*palette[i : i + 3]))
-    elif im.mode == "RGB":
-        # Populate the 4th channel with 255
-        im = im.convert("RGBA")
-
-        data = im.tobytes("raw", "BGRA")
-        format = qt_format.Format_RGB32
-    elif im.mode == "RGBA":
-        data = im.tobytes("raw", "BGRA")
-        format = qt_format.Format_ARGB32
-    elif im.mode == "I;16" and hasattr(qt_format, "Format_Grayscale16"):  # Qt 5.13+
-        im = im.point(lambda i: i * 256)
-
-        format = qt_format.Format_Grayscale16
-    else:
-        if exclusive_fp:
-            im.close()
-        raise ValueError(f"unsupported image mode {repr(im.mode)}")
-
-    size = im.size
-    __data = data or align8to32(im.tobytes(), size[0], im.mode)
-    if exclusive_fp:
-        im.close()
-    return {"data": __data, "size": size, "format": format, "colortable": colortable}
-
-
-if qt_is_installed:
-
-    class ImageQt(QImage):
-        def __init__(self, im):
-            """
-            An PIL image wrapper for Qt.  This is a subclass of PyQt's QImage
-            class.
-
-            :param im: A PIL Image object, or a file name (given either as
-                Python string or a PyQt string object).
-            """
-            im_data = _toqclass_helper(im)
-            # must keep a reference, or Qt will crash!
-            # All QImage constructors that take data operate on an existing
-            # buffer, so this buffer has to hang on for the life of the image.
-            # Fixes https://github.com/python-pillow/Pillow/issues/1370
-            self.__data = im_data["data"]
-            super().__init__(
-                self.__data,
-                im_data["size"][0],
-                im_data["size"][1],
-                im_data["format"],
-            )
-            if im_data["colortable"]:
-                self.setColorTable(im_data["colortable"])
-
-
-def toqimage(im):
-    return ImageQt(im)
-
-
-def toqpixmap(im):
-    # # This doesn't work. For now using a dumb approach.
-    # im_data = _toqclass_helper(im)
-    # result = QPixmap(im_data["size"][0], im_data["size"][1])
-    # result.loadFromData(im_data["data"])
-    qimage = toqimage(im)
-    return QPixmap.fromImage(qimage)

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageSequence.py

@@ -1,75 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# sequence support classes
-#
-# history:
-# 1997-02-20 fl     Created
-#
-# Copyright (c) 1997 by Secret Labs AB.
-# Copyright (c) 1997 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-##
-
-
-class Iterator:
-    """
-    This class implements an iterator object that can be used to loop
-    over an image sequence.
-
-    You can use the ``[]`` operator to access elements by index. This operator
-    will raise an :py:exc:`IndexError` if you try to access a nonexistent
-    frame.
-
-    :param im: An image object.
-    """
-
-    def __init__(self, im):
-        if not hasattr(im, "seek"):
-            raise AttributeError("im must have seek method")
-        self.im = im
-        self.position = getattr(self.im, "_min_frame", 0)
-
-    def __getitem__(self, ix):
-        try:
-            self.im.seek(ix)
-            return self.im
-        except EOFError as e:
-            raise IndexError from e  # end of sequence
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        try:
-            self.im.seek(self.position)
-            self.position += 1
-            return self.im
-        except EOFError as e:
-            raise StopIteration from e
-
-
-def all_frames(im, func=None):
-    """
-    Applies a given function to all frames in an image or a list of images.
-    The frames are returned as a list of separate images.
-
-    :param im: An image, or a list of images.
-    :param func: The function to apply to all of the image frames.
-    :returns: A list of images.
-    """
-    if not isinstance(im, list):
-        im = [im]
-
-    ims = []
-    for imSequence in im:
-        current = imSequence.tell()
-
-        ims += [im_frame.copy() for im_frame in Iterator(imSequence)]
-
-        imSequence.seek(current)
-    return [func(im) for im in ims] if func else ims

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageShow.py

@@ -1,392 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# im.show() drivers
-#
-# History:
-# 2008-04-06 fl   Created
-#
-# Copyright (c) Secret Labs AB 2008.
-#
-# See the README file for information on usage and redistribution.
-#
-import os
-import shutil
-import subprocess
-import sys
-from shlex import quote
-
-from PIL import Image
-
-from ._deprecate import deprecate
-
-_viewers = []
-
-
-def register(viewer, order=1):
-    """
-    The :py:func:`register` function is used to register additional viewers::
-
-        from PIL import ImageShow
-        ImageShow.register(MyViewer())  # MyViewer will be used as a last resort
-        ImageShow.register(MySecondViewer(), 0)  # MySecondViewer will be prioritised
-        ImageShow.register(ImageShow.XVViewer(), 0)  # XVViewer will be prioritised
-
-    :param viewer: The viewer to be registered.
-    :param order:
-        Zero or a negative integer to prepend this viewer to the list,
-        a positive integer to append it.
-    """
-    try:
-        if issubclass(viewer, Viewer):
-            viewer = viewer()
-    except TypeError:
-        pass  # raised if viewer wasn't a class
-    if order > 0:
-        _viewers.append(viewer)
-    else:
-        _viewers.insert(0, viewer)
-
-
-def show(image, title=None, **options):
-    r"""
-    Display a given image.
-
-    :param image: An image object.
-    :param title: Optional title. Not all viewers can display the title.
-    :param \**options: Additional viewer options.
-    :returns: ``True`` if a suitable viewer was found, ``False`` otherwise.
-    """
-    for viewer in _viewers:
-        if viewer.show(image, title=title, **options):
-            return True
-    return False
-
-
-class Viewer:
-    """Base class for viewers."""
-
-    # main api
-
-    def show(self, image, **options):
-        """
-        The main function for displaying an image.
-        Converts the given image to the target format and displays it.
-        """
-
-        if not (
-            image.mode in ("1", "RGBA")
-            or (self.format == "PNG" and image.mode in ("I;16", "LA"))
-        ):
-            base = Image.getmodebase(image.mode)
-            if image.mode != base:
-                image = image.convert(base)
-
-        return self.show_image(image, **options)
-
-    # hook methods
-
-    format = None
-    """The format to convert the image into."""
-    options = {}
-    """Additional options used to convert the image."""
-
-    def get_format(self, image):
-        """Return format name, or ``None`` to save as PGM/PPM."""
-        return self.format
-
-    def get_command(self, file, **options):
-        """
-        Returns the command used to display the file.
-        Not implemented in the base class.
-        """
-        raise NotImplementedError
-
-    def save_image(self, image):
-        """Save to temporary file and return filename."""
-        return image._dump(format=self.get_format(image), **self.options)
-
-    def show_image(self, image, **options):
-        """Display the given image."""
-        return self.show_file(self.save_image(image), **options)
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and will be removed in Pillow 10.0.0 (2023-07-01). ``path`` should be used
-        instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        os.system(self.get_command(path, **options))
-        return 1
-
-
-# --------------------------------------------------------------------
-
-
-class WindowsViewer(Viewer):
-    """The default viewer on Windows is the default system application for PNG files."""
-
-    format = "PNG"
-    options = {"compress_level": 1, "save_all": True}
-
-    def get_command(self, file, **options):
-        return (
-            f'start "Pillow" /WAIT "{file}" '
-            "&& ping -n 4 127.0.0.1 >NUL "
-            f'&& del /f "{file}"'
-        )
-
-
-if sys.platform == "win32":
-    register(WindowsViewer)
-
-
-class MacViewer(Viewer):
-    """The default viewer on macOS using ``Preview.app``."""
-
-    format = "PNG"
-    options = {"compress_level": 1, "save_all": True}
-
-    def get_command(self, file, **options):
-        # on darwin open returns immediately resulting in the temp
-        # file removal while app is opening
-        command = "open -a Preview.app"
-        command = f"({command} {quote(file)}; sleep 20; rm -f {quote(file)})&"
-        return command
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and will be removed in Pillow 10.0.0 (2023-07-01). ``path`` should be used
-        instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        subprocess.call(["open", "-a", "Preview.app", path])
-        executable = sys.executable or shutil.which("python3")
-        if executable:
-            subprocess.Popen(
-                [
-                    executable,
-                    "-c",
-                    "import os, sys, time; time.sleep(20); os.remove(sys.argv[1])",
-                    path,
-                ]
-            )
-        return 1
-
-
-if sys.platform == "darwin":
-    register(MacViewer)
-
-
-class UnixViewer(Viewer):
-    format = "PNG"
-    options = {"compress_level": 1, "save_all": True}
-
-    def get_command(self, file, **options):
-        command = self.get_command_ex(file, **options)[0]
-        return f"({command} {quote(file)}"
-
-
-class XDGViewer(UnixViewer):
-    """
-    The freedesktop.org ``xdg-open`` command.
-    """
-
-    def get_command_ex(self, file, **options):
-        command = executable = "xdg-open"
-        return command, executable
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and will be removed in Pillow 10.0.0 (2023-07-01). ``path`` should be used
-        instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        subprocess.Popen(["xdg-open", path])
-        return 1
-
-
-class DisplayViewer(UnixViewer):
-    """
-    The ImageMagick ``display`` command.
-    This viewer supports the ``title`` parameter.
-    """
-
-    def get_command_ex(self, file, title=None, **options):
-        command = executable = "display"
-        if title:
-            command += f" -title {quote(title)}"
-        return command, executable
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and ``path`` should be used instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        args = ["display"]
-        title = options.get("title")
-        if title:
-            args += ["-title", title]
-        args.append(path)
-
-        subprocess.Popen(args)
-        return 1
-
-
-class GmDisplayViewer(UnixViewer):
-    """The GraphicsMagick ``gm display`` command."""
-
-    def get_command_ex(self, file, **options):
-        executable = "gm"
-        command = "gm display"
-        return command, executable
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and ``path`` should be used instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        subprocess.Popen(["gm", "display", path])
-        return 1
-
-
-class EogViewer(UnixViewer):
-    """The GNOME Image Viewer ``eog`` command."""
-
-    def get_command_ex(self, file, **options):
-        executable = "eog"
-        command = "eog -n"
-        return command, executable
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and ``path`` should be used instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        subprocess.Popen(["eog", "-n", path])
-        return 1
-
-
-class XVViewer(UnixViewer):
-    """
-    The X Viewer ``xv`` command.
-    This viewer supports the ``title`` parameter.
-    """
-
-    def get_command_ex(self, file, title=None, **options):
-        # note: xv is pretty outdated.  most modern systems have
-        # imagemagick's display command instead.
-        command = executable = "xv"
-        if title:
-            command += f" -name {quote(title)}"
-        return command, executable
-
-    def show_file(self, path=None, **options):
-        """
-        Display given file.
-
-        Before Pillow 9.1.0, the first argument was ``file``. This is now deprecated,
-        and ``path`` should be used instead.
-        """
-        if path is None:
-            if "file" in options:
-                deprecate("The 'file' argument", 10, "'path'")
-                path = options.pop("file")
-            else:
-                raise TypeError("Missing required argument: 'path'")
-        args = ["xv"]
-        title = options.get("title")
-        if title:
-            args += ["-name", title]
-        args.append(path)
-
-        subprocess.Popen(args)
-        return 1
-
-
-if sys.platform not in ("win32", "darwin"):  # unixoids
-    if shutil.which("xdg-open"):
-        register(XDGViewer)
-    if shutil.which("display"):
-        register(DisplayViewer)
-    if shutil.which("gm"):
-        register(GmDisplayViewer)
-    if shutil.which("eog"):
-        register(EogViewer)
-    if shutil.which("xv"):
-        register(XVViewer)
-
-
-class IPythonViewer(Viewer):
-    """The viewer for IPython frontends."""
-
-    def show_image(self, image, **options):
-        ipython_display(image)
-        return 1
-
-
-try:
-    from IPython.display import display as ipython_display
-except ImportError:
-    pass
-else:
-    register(IPythonViewer)
-
-
-if __name__ == "__main__":
-
-    if len(sys.argv) < 2:
-        print("Syntax: python3 ImageShow.py imagefile [title]")
-        sys.exit()
-
-    with Image.open(sys.argv[1]) as im:
-        print(show(im, *sys.argv[2:]))

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageStat.py

@@ -1,147 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# global image statistics
-#
-# History:
-# 1996-04-05 fl   Created
-# 1997-05-21 fl   Added mask; added rms, var, stddev attributes
-# 1997-08-05 fl   Added median
-# 1998-07-05 hk   Fixed integer overflow error
-#
-# Notes:
-# This class shows how to implement delayed evaluation of attributes.
-# To get a certain value, simply access the corresponding attribute.
-# The __getattr__ dispatcher takes care of the rest.
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1996-97.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import functools
-import math
-import operator
-
-
-class Stat:
-    def __init__(self, image_or_list, mask=None):
-        try:
-            if mask:
-                self.h = image_or_list.histogram(mask)
-            else:
-                self.h = image_or_list.histogram()
-        except AttributeError:
-            self.h = image_or_list  # assume it to be a histogram list
-        if not isinstance(self.h, list):
-            raise TypeError("first argument must be image or list")
-        self.bands = list(range(len(self.h) // 256))
-
-    def __getattr__(self, id):
-        """Calculate missing attribute"""
-        if id[:4] == "_get":
-            raise AttributeError(id)
-        # calculate missing attribute
-        v = getattr(self, "_get" + id)()
-        setattr(self, id, v)
-        return v
-
-    def _getextrema(self):
-        """Get min/max values for each band in the image"""
-
-        def minmax(histogram):
-            n = 255
-            x = 0
-            for i in range(256):
-                if histogram[i]:
-                    n = min(n, i)
-                    x = max(x, i)
-            return n, x  # returns (255, 0) if there's no data in the histogram
-
-        v = []
-        for i in range(0, len(self.h), 256):
-            v.append(minmax(self.h[i:]))
-        return v
-
-    def _getcount(self):
-        """Get total number of pixels in each layer"""
-
-        v = []
-        for i in range(0, len(self.h), 256):
-            v.append(functools.reduce(operator.add, self.h[i : i + 256]))
-        return v
-
-    def _getsum(self):
-        """Get sum of all pixels in each layer"""
-
-        v = []
-        for i in range(0, len(self.h), 256):
-            layer_sum = 0.0
-            for j in range(256):
-                layer_sum += j * self.h[i + j]
-            v.append(layer_sum)
-        return v
-
-    def _getsum2(self):
-        """Get squared sum of all pixels in each layer"""
-
-        v = []
-        for i in range(0, len(self.h), 256):
-            sum2 = 0.0
-            for j in range(256):
-                sum2 += (j**2) * float(self.h[i + j])
-            v.append(sum2)
-        return v
-
-    def _getmean(self):
-        """Get average pixel level for each layer"""
-
-        v = []
-        for i in self.bands:
-            v.append(self.sum[i] / self.count[i])
-        return v
-
-    def _getmedian(self):
-        """Get median pixel level for each layer"""
-
-        v = []
-        for i in self.bands:
-            s = 0
-            half = self.count[i] // 2
-            b = i * 256
-            for j in range(256):
-                s = s + self.h[b + j]
-                if s > half:
-                    break
-            v.append(j)
-        return v
-
-    def _getrms(self):
-        """Get RMS for each layer"""
-
-        v = []
-        for i in self.bands:
-            v.append(math.sqrt(self.sum2[i] / self.count[i]))
-        return v
-
-    def _getvar(self):
-        """Get variance for each layer"""
-
-        v = []
-        for i in self.bands:
-            n = self.count[i]
-            v.append((self.sum2[i] - (self.sum[i] ** 2.0) / n) / n)
-        return v
-
-    def _getstddev(self):
-        """Get standard deviation for each layer"""
-
-        v = []
-        for i in self.bands:
-            v.append(math.sqrt(self.var[i]))
-        return v
-
-
-Global = Stat  # compatibility

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageTk.py

@@ -1,291 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a Tk display interface
-#
-# History:
-# 96-04-08 fl   Created
-# 96-09-06 fl   Added getimage method
-# 96-11-01 fl   Rewritten, removed image attribute and crop method
-# 97-05-09 fl   Use PyImagingPaste method instead of image type
-# 97-05-12 fl   Minor tweaks to match the IFUNC95 interface
-# 97-05-17 fl   Support the "pilbitmap" booster patch
-# 97-06-05 fl   Added file= and data= argument to image constructors
-# 98-03-09 fl   Added width and height methods to Image classes
-# 98-07-02 fl   Use default mode for "P" images without palette attribute
-# 98-07-02 fl   Explicitly destroy Tkinter image objects
-# 99-07-24 fl   Support multiple Tk interpreters (from Greg Couch)
-# 99-07-26 fl   Automatically hook into Tkinter (if possible)
-# 99-08-15 fl   Hook uses _imagingtk instead of _imaging
-#
-# Copyright (c) 1997-1999 by Secret Labs AB
-# Copyright (c) 1996-1997 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import tkinter
-from io import BytesIO
-
-from . import Image
-from ._deprecate import deprecate
-
-# --------------------------------------------------------------------
-# Check for Tkinter interface hooks
-
-_pilbitmap_ok = None
-
-
-def _pilbitmap_check():
-    global _pilbitmap_ok
-    if _pilbitmap_ok is None:
-        try:
-            im = Image.new("1", (1, 1))
-            tkinter.BitmapImage(data=f"PIL:{im.im.id}")
-            _pilbitmap_ok = 1
-        except tkinter.TclError:
-            _pilbitmap_ok = 0
-    return _pilbitmap_ok
-
-
-def _get_image_from_kw(kw):
-    source = None
-    if "file" in kw:
-        source = kw.pop("file")
-    elif "data" in kw:
-        source = BytesIO(kw.pop("data"))
-    if source:
-        return Image.open(source)
-
-
-def _pyimagingtkcall(command, photo, id):
-    tk = photo.tk
-    try:
-        tk.call(command, photo, id)
-    except tkinter.TclError:
-        # activate Tkinter hook
-        # may raise an error if it cannot attach to Tkinter
-        from . import _imagingtk
-
-        _imagingtk.tkinit(tk.interpaddr())
-        tk.call(command, photo, id)
-
-
-# --------------------------------------------------------------------
-# PhotoImage
-
-
-class PhotoImage:
-    """
-    A Tkinter-compatible photo image.  This can be used
-    everywhere Tkinter expects an image object.  If the image is an RGBA
-    image, pixels having alpha 0 are treated as transparent.
-
-    The constructor takes either a PIL image, or a mode and a size.
-    Alternatively, you can use the ``file`` or ``data`` options to initialize
-    the photo image object.
-
-    :param image: Either a PIL image, or a mode string.  If a mode string is
-                  used, a size must also be given.
-    :param size: If the first argument is a mode string, this defines the size
-                 of the image.
-    :keyword file: A filename to load the image from (using
-                   ``Image.open(file)``).
-    :keyword data: An 8-bit string containing image data (as loaded from an
-                   image file).
-    """
-
-    def __init__(self, image=None, size=None, **kw):
-
-        # Tk compatibility: file or data
-        if image is None:
-            image = _get_image_from_kw(kw)
-
-        if hasattr(image, "mode") and hasattr(image, "size"):
-            # got an image instead of a mode
-            mode = image.mode
-            if mode == "P":
-                # palette mapped data
-                image.apply_transparency()
-                image.load()
-                try:
-                    mode = image.palette.mode
-                except AttributeError:
-                    mode = "RGB"  # default
-            size = image.size
-            kw["width"], kw["height"] = size
-        else:
-            mode = image
-            image = None
-
-        if mode not in ["1", "L", "RGB", "RGBA"]:
-            mode = Image.getmodebase(mode)
-
-        self.__mode = mode
-        self.__size = size
-        self.__photo = tkinter.PhotoImage(**kw)
-        self.tk = self.__photo.tk
-        if image:
-            self.paste(image)
-
-    def __del__(self):
-        name = self.__photo.name
-        self.__photo.name = None
-        try:
-            self.__photo.tk.call("image", "delete", name)
-        except Exception:
-            pass  # ignore internal errors
-
-    def __str__(self):
-        """
-        Get the Tkinter photo image identifier.  This method is automatically
-        called by Tkinter whenever a PhotoImage object is passed to a Tkinter
-        method.
-
-        :return: A Tkinter photo image identifier (a string).
-        """
-        return str(self.__photo)
-
-    def width(self):
-        """
-        Get the width of the image.
-
-        :return: The width, in pixels.
-        """
-        return self.__size[0]
-
-    def height(self):
-        """
-        Get the height of the image.
-
-        :return: The height, in pixels.
-        """
-        return self.__size[1]
-
-    def paste(self, im, box=None):
-        """
-        Paste a PIL image into the photo image.  Note that this can
-        be very slow if the photo image is displayed.
-
-        :param im: A PIL image. The size must match the target region.  If the
-                   mode does not match, the image is converted to the mode of
-                   the bitmap image.
-        :param box: Deprecated. This parameter will be removed in Pillow 10
-                    (2023-07-01).
-        """
-
-        if box is not None:
-            deprecate("The box parameter", 10, None)
-
-        # convert to blittable
-        im.load()
-        image = im.im
-        if image.isblock() and im.mode == self.__mode:
-            block = image
-        else:
-            block = image.new_block(self.__mode, im.size)
-            image.convert2(block, image)  # convert directly between buffers
-
-        _pyimagingtkcall("PyImagingPhoto", self.__photo, block.id)
-
-
-# --------------------------------------------------------------------
-# BitmapImage
-
-
-class BitmapImage:
-    """
-    A Tkinter-compatible bitmap image.  This can be used everywhere Tkinter
-    expects an image object.
-
-    The given image must have mode "1".  Pixels having value 0 are treated as
-    transparent.  Options, if any, are passed on to Tkinter.  The most commonly
-    used option is ``foreground``, which is used to specify the color for the
-    non-transparent parts.  See the Tkinter documentation for information on
-    how to specify colours.
-
-    :param image: A PIL image.
-    """
-
-    def __init__(self, image=None, **kw):
-
-        # Tk compatibility: file or data
-        if image is None:
-            image = _get_image_from_kw(kw)
-
-        self.__mode = image.mode
-        self.__size = image.size
-
-        if _pilbitmap_check():
-            # fast way (requires the pilbitmap booster patch)
-            image.load()
-            kw["data"] = f"PIL:{image.im.id}"
-            self.__im = image  # must keep a reference
-        else:
-            # slow but safe way
-            kw["data"] = image.tobitmap()
-        self.__photo = tkinter.BitmapImage(**kw)
-
-    def __del__(self):
-        name = self.__photo.name
-        self.__photo.name = None
-        try:
-            self.__photo.tk.call("image", "delete", name)
-        except Exception:
-            pass  # ignore internal errors
-
-    def width(self):
-        """
-        Get the width of the image.
-
-        :return: The width, in pixels.
-        """
-        return self.__size[0]
-
-    def height(self):
-        """
-        Get the height of the image.
-
-        :return: The height, in pixels.
-        """
-        return self.__size[1]
-
-    def __str__(self):
-        """
-        Get the Tkinter bitmap image identifier.  This method is automatically
-        called by Tkinter whenever a BitmapImage object is passed to a Tkinter
-        method.
-
-        :return: A Tkinter bitmap image identifier (a string).
-        """
-        return str(self.__photo)
-
-
-def getimage(photo):
-    """Copies the contents of a PhotoImage to a PIL image memory."""
-    im = Image.new("RGBA", (photo.width(), photo.height()))
-    block = im.im
-
-    _pyimagingtkcall("PyImagingPhotoGet", photo, block.id)
-
-    return im
-
-
-def _show(image, title):
-    """Helper for the Image.show method."""
-
-    class UI(tkinter.Label):
-        def __init__(self, master, im):
-            if im.mode == "1":
-                self.image = BitmapImage(im, foreground="white", master=master)
-            else:
-                self.image = PhotoImage(im, master=master)
-            super().__init__(master, image=self.image, bg="black", bd=0)
-
-    if not tkinter._default_root:
-        raise OSError("tkinter not initialized")
-    top = tkinter.Toplevel()
-    if title:
-        top.title(title)
-    UI(top, image).pack()

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageTransform.py

@@ -1,102 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# transform wrappers
-#
-# History:
-# 2002-04-08 fl   Created
-#
-# Copyright (c) 2002 by Secret Labs AB
-# Copyright (c) 2002 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image
-
-
-class Transform(Image.ImageTransformHandler):
-    def __init__(self, data):
-        self.data = data
-
-    def getdata(self):
-        return self.method, self.data
-
-    def transform(self, size, image, **options):
-        # can be overridden
-        method, data = self.getdata()
-        return image.transform(size, method, data, **options)
-
-
-class AffineTransform(Transform):
-    """
-    Define an affine image transform.
-
-    This function takes a 6-tuple (a, b, c, d, e, f) which contain the first
-    two rows from an affine transform matrix. For each pixel (x, y) in the
-    output image, the new value is taken from a position (a x + b y + c,
-    d x + e y + f) in the input image, rounded to nearest pixel.
-
-    This function can be used to scale, translate, rotate, and shear the
-    original image.
-
-    See :py:meth:`~PIL.Image.Image.transform`
-
-    :param matrix: A 6-tuple (a, b, c, d, e, f) containing the first two rows
-        from an affine transform matrix.
-    """
-
-    method = Image.Transform.AFFINE
-
-
-class ExtentTransform(Transform):
-    """
-    Define a transform to extract a subregion from an image.
-
-    Maps a rectangle (defined by two corners) from the image to a rectangle of
-    the given size. The resulting image will contain data sampled from between
-    the corners, such that (x0, y0) in the input image will end up at (0,0) in
-    the output image, and (x1, y1) at size.
-
-    This method can be used to crop, stretch, shrink, or mirror an arbitrary
-    rectangle in the current image. It is slightly slower than crop, but about
-    as fast as a corresponding resize operation.
-
-    See :py:meth:`~PIL.Image.Image.transform`
-
-    :param bbox: A 4-tuple (x0, y0, x1, y1) which specifies two points in the
-        input image's coordinate system. See :ref:`coordinate-system`.
-    """
-
-    method = Image.Transform.EXTENT
-
-
-class QuadTransform(Transform):
-    """
-    Define a quad image transform.
-
-    Maps a quadrilateral (a region defined by four corners) from the image to a
-    rectangle of the given size.
-
-    See :py:meth:`~PIL.Image.Image.transform`
-
-    :param xy: An 8-tuple (x0, y0, x1, y1, x2, y2, x3, y3) which contain the
-        upper left, lower left, lower right, and upper right corner of the
-        source quadrilateral.
-    """
-
-    method = Image.Transform.QUAD
-
-
-class MeshTransform(Transform):
-    """
-    Define a mesh image transform.  A mesh transform consists of one or more
-    individual quad transforms.
-
-    See :py:meth:`~PIL.Image.Image.transform`
-
-    :param data: A list of (bbox, quad) tuples.
-    """
-
-    method = Image.Transform.MESH

applications_user/FlipperPrinceOfArabia/fxdata/Arduboy-Python-Utilities-master/PIL/ImageWin.py

@@ -1,230 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a Windows DIB display interface
-#
-# History:
-# 1996-05-20 fl   Created
-# 1996-09-20 fl   Fixed subregion exposure
-# 1997-09-21 fl   Added draw primitive (for tzPrint)
-# 2003-05-21 fl   Added experimental Window/ImageWindow classes
-# 2003-09-05 fl   Added fromstring/tostring methods
-#
-# Copyright (c) Secret Labs AB 1997-2003.
-# Copyright (c) Fredrik Lundh 1996-2003.
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image
-
-
-class HDC:
-    """
-    Wraps an HDC integer. The resulting object can be passed to the
-    :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose`
-    methods.
-    """
-
-    def __init__(self, dc):
-        self.dc = dc
-
-    def __int__(self):
-        return self.dc
-
-
-class HWND:
-    """
-    Wraps an HWND integer. The resulting object can be passed to the
-    :py:meth:`~PIL.ImageWin.Dib.draw` and :py:meth:`~PIL.ImageWin.Dib.expose`
-    methods, instead of a DC.
-    """
-
-    def __init__(self, wnd):
-        self.wnd = wnd
-
-    def __int__(self):
-        return self.wnd
-
-
-class Dib:
-    """
-    A Windows bitmap with the given mode and size.  The mode can be one of "1",
-    "L", "P", or "RGB".
-
-    If the display requires a palette, this constructor creates a suitable
-    palette and associates it with the image. For an "L" image, 128 greylevels
-    are allocated. For an "RGB" image, a 6x6x6 colour cube is used, together
-    with 20 greylevels.
-
-    To make sure that palettes work properly under Windows, you must call the
-    ``palette`` method upon certain events from Windows.
-
-    :param image: Either a PIL image, or a mode string. If a mode string is
-                  used, a size must also be given.  The mode can be one of "1",
-                  "L", "P", or "RGB".
-    :param size: If the first argument is a mode string, this
-                 defines the size of the image.
-    """
-
-    def __init__(self, image, size=None):
-        if hasattr(image, "mode") and hasattr(image, "size"):
-            mode = image.mode
-            size = image.size
-        else:
-            mode = image
-            image = None
-        if mode not in ["1", "L", "P", "RGB"]:
-            mode = Image.getmodebase(mode)
-        self.image = Image.core.display(mode, size)
-        self.mode = mode
-        self.size = size
-        if image:
-            self.paste(image)
-
-    def expose(self, handle):
-        """
-        Copy the bitmap contents to a device context.
-
-        :param handle: Device context (HDC), cast to a Python integer, or an
-                       HDC or HWND instance.  In PythonWin, you can use
-                       ``CDC.GetHandleAttrib()`` to get a suitable handle.
-        """
-        if isinstance(handle, HWND):
-            dc = self.image.getdc(handle)
-            try:
-                result = self.image.expose(dc)
-            finally:
-                self.image.releasedc(handle, dc)
-        else:
-            result = self.image.expose(handle)
-        return result
-
-    def draw(self, handle, dst, src=None):
-        """
-        Same as expose, but allows you to specify where to draw the image, and
-        what part of it to draw.
-
-        The destination and source areas are given as 4-tuple rectangles. If
-        the source is omitted, the entire image is copied. If the source and
-        the destination have different sizes, the image is resized as
-        necessary.
-        """
-        if not src:
-            src = (0, 0) + self.size
-        if isinstance(handle, HWND):
-            dc = self.image.getdc(handle)
-            try:
-                result = self.image.draw(dc, dst, src)
-            finally:
-                self.image.releasedc(handle, dc)
-        else:
-            result = self.image.draw(handle, dst, src)
-        return result
-
-    def query_palette(self, handle):
-        """
-        Installs the palette associated with the image in the given device
-        context.
-
-        This method should be called upon **QUERYNEWPALETTE** and
-        **PALETTECHANGED** events from Windows. If this method returns a
-        non-zero value, one or more display palette entries were changed, and
-        the image should be redrawn.
-
-        :param handle: Device context (HDC), cast to a Python integer, or an
-                       HDC or HWND instance.
-        :return: A true value if one or more entries were changed (this
-                 indicates that the image should be redrawn).
-        """
-        if isinstance(handle, HWND):
-            handle = self.image.getdc(handle)
-            try:
-                result = self.image.query_palette(handle)
-            finally:
-                self.image.releasedc(handle, handle)
-        else:
-            result = self.image.query_palette(handle)
-        return result
-
-    def paste(self, im, box=None):
-        """
-        Paste a PIL image into the bitmap image.
-
-        :param im: A PIL image.  The size must match the target region.
-                   If the mode does not match, the image is converted to the
-                   mode of the bitmap image.
-        :param box: A 4-tuple defining the left, upper, right, and
-                    lower pixel coordinate.  See :ref:`coordinate-system`. If
-                    None is given instead of a tuple, all of the image is
-                    assumed.
-        """
-        im.load()
-        if self.mode != im.mode:
-            im = im.convert(self.mode)
-        if box:
-            self.image.paste(im.im, box)
-        else:
-            self.image.paste(im.im)
-
-    def frombytes(self, buffer):
-        """
-        Load display memory contents from byte data.
-
-        :param buffer: A buffer containing display data (usually
-                       data returned from :py:func:`~PIL.ImageWin.Dib.tobytes`)
-        """
-        return self.image.frombytes(buffer)
-
-    def tobytes(self):
-        """
-        Copy display memory contents to bytes object.
-
-        :return: A bytes object containing display data.
-        """
-        return self.image.tobytes()
-
-
-class Window:
-    """Create a Window with the given title size."""
-
-    def __init__(self, title="PIL", width=None, height=None):
-        self.hwnd = Image.core.createwindow(
-            title, self.__dispatcher, width or 0, height or 0
-        )
-
-    def __dispatcher(self, action, *args):
-        return getattr(self, "ui_handle_" + action)(*args)
-
-    def ui_handle_clear(self, dc, x0, y0, x1, y1):
-        pass
-
-    def ui_handle_damage(self, x0, y0, x1, y1):
-        pass
-
-    def ui_handle_destroy(self):
-        pass
-
-    def ui_handle_repair(self, dc, x0, y0, x1, y1):
-        pass
-
-    def ui_handle_resize(self, width, height):
-        pass
-
-    def mainloop(self):
-        Image.core.eventloop()
-
-
-class ImageWindow(Window):
-    """Create an image window which displays the given image."""
-
-    def __init__(self, image, title="PIL"):
-        if not isinstance(image, Dib):
-            image = Dib(image)
-        self.image = image
-        width, height = image.size
-        super().__init__(title, width=width, height=height)
-
-    def ui_handle_repair(self, dc, x0, y0, x1, y1):
-        self.image.draw(dc, (x0, y0, x1, y1))