changed log message

log the uncatched MQTT connection error
Merge branch 'main' of https://github.com/jomjol/AI-on-the-edge-device
2025-12-06 19:46:54 +03:00 · 2024-10-06 16:49:48 +02:00 · 2024-10-06 16:44:43 +02:00 · 2024-10-06 16:43:51 +02:00 · 2024-10-05 23:15:38 +02:00 · 2024-10-05 22:42:51 +02:00
724 changed files with 48300 additions and 112168 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -0,0 +1,67 @@
+name: 🐞 Bug Report
+description: Use this form if you think you found a bug / Verwende dieses Formular, wenn Du denkst, dass Du einen Fehler gefunden hast.
+labels: bug
+body:
+
+
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking your time to report a bug.
+
+        Before you proceed, please check:
+        - [ ] Do you use the [latest version](https://github.com/jomjol/AI-on-the-edge-device/releases)?
+        - [ ] Is there already another similar issue? Check for open and closed [Issue](https://github.com/jomjol/AI-on-the-edge-device/issues) and [Discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions).
+        - [ ] Are instructions in the [README](https://github.com/jomjol/AI-on-the-edge-device/tree/master#readme) solving your issue?
+        - [ ] Are instructions in the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki) solving your issue?
+        
+        Du darfst gerne auch in Deutsch schreiben!
+
+
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: The Problem
+      description: A clear and concise description of what the bug is.
+
+
+
+  - type: input
+    validations:
+      required: true
+    attributes:
+      label: Version
+      description: Which version are you using? (See menu `System > Info`).    
+        
+        
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Logfile
+      description: Add the logfile (See menu `System > Log Viewer`) to help explain your problem. This will be automatically formatted into code, so no need to format it on your side.
+      render: shell
+
+
+
+  - type: textarea
+    attributes:
+      label: Expected Behavior
+      description: A clear and concise description of what you expected to happen.
+        
+
+
+  - type: textarea
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem.
+        
+
+
+  - type: textarea
+    attributes:
+      label: Additional Context
+      description: Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/config.yaml
+++ b/.github/ISSUE_TEMPLATE/config.yaml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💬 Open a new Discussion
+    url: https://github.com/jomjol/AI-on-the-edge-device/discussions/categories/q-a
+    about: Use this form if you have a question or need help setting your AI-on-the-edge-device it up
--- a/.github/ISSUE_TEMPLATE/feature.yaml
+++ b/.github/ISSUE_TEMPLATE/feature.yaml
@@ -0,0 +1,23 @@
+name: 💡 Feature Request
+description: Use this form if you have an idea or wish for a new feature
+labels: enhancement
+body:
+
+
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking your time to document your idea.
+
+        Before you proceed, please check:
+        - [ ] Is there already another similar issue open or closed? Check for open and closed [Issue](https://github.com/jomjol/AI-on-the-edge-device/issues) and [Discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions).
+        - [ ] Is there already another similar [discussion](https://github.com/jomjol/AI-on-the-edge-device/discussions) ongoing?
+
+        Please be aware that we might decline your request if we have a reason for it!
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: The Feature
+      description: A clear and concise description of what the new feature should do. If possible, refer to other projects or add a mockup.
--- a/.github/ISSUE_TEMPLATE/training.yaml
+++ b/.github/ISSUE_TEMPLATE/training.yaml
@@ -0,0 +1,19 @@
+name: 📖 New Training Data
+description: Use this form if you collected images and want to provide them for training the model
+title: New Training Data
+labels: new training data
+assignees: jomjol
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Before you proceed, please check:
+        - [ ] Did you make sure we don't have similar data yet in the training data? (see [Digital Counters](https://jomjol.github.io/neural-network-digital-counter-readout/) resp. [Analog Needles](https://jomjol.github.io/neural-network-analog-needle-readout))
+        - [ ] Did you follow the guideline as documented in the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/ROI-Configuration)? We will only be able to accept the files if they fulfill the rules!
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Files
+      description: You can drag & drop your **zipped** images here
--- a/.github/ISSUE_TEMPLATE/x_plain.yaml
+++ b/.github/ISSUE_TEMPLATE/x_plain.yaml
@@ -0,0 +1,8 @@
+name: 🗒️ Blank Form
+description: Use this form if none of the others fit. Please only use none of the others fit!
+
+body:
+  - type: textarea
+    attributes:
+      label: Issue
+  
--- a/.github/label-commenter-config.yaml
+++ b/.github/label-commenter-config.yaml
@@ -0,0 +1,123 @@
+# Reply Bot Configuration
+# See https://github.com/peaceiris/actions-label-commenter
+# Make sure to also add the response to .github/workflows/reply-bot.yml!
+# Due to the way it works, you have to add each response twice, once for the issue, once for the discussions!
+  
+ labels:
+  #######################################################################
+  # Bot Response: Documentation
+  #######################################################################
+  - name: bot-reply Documentation
+    labeled:
+      issue:
+          body: |
+            Please have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs
+      discussion:
+          body: |
+            Please have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs
+
+  #######################################################################
+  # Bot Response: ROI setup
+  #######################################################################
+  - name: bot-reply ROI Setup
+    labeled:
+      issue:
+          body: |
+            Make sure to setup your ROIs properly. Have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs/ROI-Configuration/#how-to-setup-the-digit-rois-perfectly
+      discussion:
+          body: |
+            Make sure to setup your ROIs properly. Have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs/ROI-Configuration/#how-to-setup-the-digit-rois-perfectly
+
+
+  #######################################################################
+  # Bot Response: Logfile
+  #######################################################################
+  - name: bot-reply Logfile
+    labeled:
+      issue:
+          body: |
+            Please provide a logfile!
+            Make sure to first enable the `DEBUG` level in `Settings->Configuration->Debug->Logfile Log Level`!
+            Then wait until the issue arises again.
+            When you copy the log into here, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+      discussion:
+          body: |
+            Please provide a logfile!
+            Make sure to first enable the `DEBUG` level in `Settings->Configuration->Debug->Logfile Log Level`!
+            Then wait until the issue arises again.
+            When you copy the log into here, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+
+
+  #######################################################################
+  # Bot Response: Web Console
+  #######################################################################
+  - name: bot-reply Web Console
+    labeled:
+      issue:
+          body: |
+            You can use the [Web Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) to get USB log from the device.
+            The USB log contains more information about the startup and operation of the device than the normal Web UI log
+            When you copy the log into herm, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+      discussion:
+          body: |
+            You can use the [Web Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) to get USB log from the device.
+            The USB log contains more information about the startup and operation of the device than the normal Web UI log
+            When you copy the log into herm, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+
+
+  #######################################################################
+  # Bot Response: Properly Format Code
+  #######################################################################
+  - name: bot-reply Properly Format Code
+    labeled:
+      issue:
+          body: |
+            Please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+            This makes your code or log much easier to read!
+      discussion:
+          body: |
+            Please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+            This makes your code or log much easier to read!
+
+
+  #######################################################################
+  # Bot Response: Web Installer
+  #######################################################################
+  - name: bot-reply Web Installer
+    labeled:
+      issue:
+          body: |
+            You can use the [Web Installer](https://jomjol.github.io/AI-on-the-edge-device/index.html) install the firmware onto the ESP32.
+      discussion:
+          body: |
+            You can use the [Web Installer](https://jomjol.github.io/AI-on-the-edge-device/index.html) install the firmware onto the ESP32.
+
+
+  #######################################################################
+  # Bot Response: Rolling Build
+  #######################################################################
+  - name: bot-reply Rolling Build
+    labeled:
+      issue:
+          body: |
+            You can try the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling+event%3Apush) of the the `rolling` or any other branch. It might already contain a fix for your issue.
+            See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/rolling-installation) for additional information.
+      discussion:
+          body: |
+            You can try the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling+event%3Apush) of the the `rolling` or any other branch. It might already contain a fix for your issue.
+            See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/rolling-installation) for additional information.
+            
+            
+  #######################################################################
+  # Bot Response: Show Trained Digits/Pointers
+  #######################################################################
+  - name: bot-reply Show Trained Digits/Pointers
+    labeled:
+      issue:
+          body: |
+            See [Digits](https://jomjol.github.io/neural-network-digital-counter-readout) resp. [Analogue Pointers](https://jomjol.github.io/neural-network-analog-needle-readout) for an overview of all trained data.
+            If your type is not contained it can be added to our training material, see [here](https://jomjol.github.io/AI-on-the-edge-device-docs/collect-new-images/).
+      discussion:
+          body: |
+            See [Digits](https://jomjol.github.io/neural-network-digital-counter-readout) resp. [Analogue Pointers](https://jomjol.github.io/neural-network-analog-needle-readout) for an overview of all trained data.
+            If your type is not contained it can be added to our training material, see [here](https://jomjol.github.io/AI-on-the-edge-device-docs/collect-new-images/).
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,425 @@
+name: Build and Pack
+
+on: [push, pull_request]
+
+jobs:
+#########################################################################################
+## Build Firmware
+#########################################################################################
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - id: skip_check
+      uses: fkirc/skip-duplicate-actions@v5
+      with:
+        concurrent_skipping: same_content_newer
+
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+    - name: Update PIP cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: pip-${{ github.run_id }}
+        restore-keys: pip # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update PlatformIO cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio
+        key: platformio-${{ github.run_id }}
+        restore-keys: platformio # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update Build cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ./code/.pio/
+        key: build-${{ github.run_id }}
+        restore-keys: build # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache          
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+
+    - name: Build Firmware
+      #run: echo "Testing... ${{ github.ref_name }}, ${{ steps.vars.outputs.sha_short }}" > ./sd-card/html/version.txt; mkdir -p ./code/.pio/build/esp32cam/; cd ./code/.pio/build/esp32cam/; echo "${{ steps.vars.outputs.sha_short }}" > firmware.bin; cp firmware.bin partitions.bin; cp firmware.bin bootloader.bin # Testing
+      run: cd code; platformio run --environment esp32cam
+
+    - name: Prepare Web UI (generate tooltip pages and update hashes in all files)
+      run: |
+        rm -rf ./html
+        mkdir html
+        cp -r ./sd-card/html/* ./html/
+
+        python -m pip install markdown
+        mkdir html/param-tooltips
+        cd tools/parameter-tooltip-generator
+        python generate-param-doc-tooltips.py
+        cd ../..
+
+        cp -r ./sd-card/html/* ./html/
+
+        echo "Replacing variables..."
+        cd html; find . -type f -exec sed -i 's/$COMMIT_HASH/${{ steps.vars.outputs.sha_short }}/g' {} \;
+
+
+#########################################################################################
+## Pack for Update
+#########################################################################################
+  pack-for-update:
+    # New OTA concept
+    # update__version.zip file with following content:
+    #  - /firmware.bin
+    #  - (optional) /html/* (inkl. subfolders)
+    #  - (optional) /config/*.tfl
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare update__*.zip artifact
+      run: |
+        rm -rf ./update
+        mkdir -p ./update
+        cp "./code/.pio/build/esp32cam/firmware.bin" "update/firmware.bin"
+
+    - name: Add Web UI to update
+      run: cp -r ./html ./update/
+
+    - name: Add CNN to update
+      run: |
+        rm -rf ./update/config/
+        mkdir -p ./update/config/
+        cp ./sd-card/config/*.tfl ./update/config/ 2>/dev/null || true
+        cp ./sd-card/config/*.tflite ./update/config/ 2>/dev/null || true
+
+    - name: Upload update as update.zip artifact (Firmware + Web UI + CNN)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./update/*
+
+
+#########################################################################################
+## Pack for Remote Setup 
+#########################################################################################
+  pack-for-remote_setup:
+    # New Remote Setup concept
+    # remote_setup__version.zip file with following content:
+    #  - /firmware.bin
+    #  - /html/* (inkl. subfolders)
+    #  - /config/*
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare remote_setup__*.zip artifact
+      run: |
+        rm -rf ./remote_setup
+        mkdir -p ./remote_setup
+
+    - name: Add Web UI to remote_setup
+      run: cp -r ./html ./remote_setup/
+
+    - name: Add whole config folder to remote_setup
+      run: |
+        rm -rf ./remote_setup/config/
+        mkdir -p ./remote_setup/config/
+        cp ./sd-card/config/* ./remote_setup/config/ 2>/dev/null || true
+
+    - name: Upload remote_setup as remote_setup.zip artifact (Firmware + Web UI + Config)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./remote_setup/*
+
+
+#########################################################################################
+## Pack for a fresh install (USB flashing) (manual_setup)
+#########################################################################################
+  pack-for-manual_setup:
+    # creates old style binaries for fresh installation (backward compatible to wiki)
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare manual_setup__*.zip artifact
+      run: |
+        rm -rf manual_setup
+        mkdir -p manual_setup
+        rm -rf manual_setup/*.zip
+        rm -rf release
+        mkdir -p release
+        # copy builds to manual_setup folder
+        cp -f "./code/.pio/build/esp32cam/firmware.bin" "manual_setup/firmware.bin"
+        cp -f "./code/.pio/build/esp32cam/bootloader.bin" "manual_setup/bootloader.bin"
+        cp -f "./code/.pio/build/esp32cam/partitions.bin" "manual_setup/partitions.bin"
+        rm -rf ./sd-card/html
+        cp -r ./html ./sd-card/ # Overwrite the Web UI with the preprocessed files
+        cd sd-card; zip -r ../manual_setup/sd-card.zip *; cd ..
+        cd ./manual_setup
+
+    - name: Upload manual_setup.zip artifact (Firmware + Bootloader + Partitions + Web UI)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./manual_setup
+
+
+#########################################################################################
+## Prepare and create release
+#########################################################################################
+  release: 
+    runs-on: ubuntu-latest
+    needs: [pack-for-update, pack-for-manual_setup, pack-for-remote_setup]
+    if: startsWith(github.ref, 'refs/tags/') 
+
+    # Sets permissions of the GITHUB_TOKEN to allow updating the branches
+    permissions:
+      contents: write
+      pages: write
+      id-token: write
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare artifacts for release
+      run: |
+        rm -rf release
+        mkdir -p release
+
+        # create AI-on-the-edge-device__update__*.zip like "AI-on-the-edge-device__update__v13.0.5.zip"
+        cd ./update
+        zip -r ../release/AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__manual-setup__*.zip like "AI-on-the-edge-device__manual-setup__v13.0.5.zip"
+        cd ../manual_setup
+        zip -r ../release/AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__remote-setup__*.zip like "AI-on-the-edge-device__remote-setup__v13.0.5.zip"
+        cd ../remote_setup
+        zip -r ../release/AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}.zip .
+
+    # extract the version used in next step
+    - id: get_version
+      uses: drewg13/get-version-action@98dda2a47a257e202c2e6c2ed2e6072ec23f448e
+
+#    # the changelog [unreleased] will now be changed to the release version
+#    - name: Update changelog
+#      uses: thomaseizinger/keep-a-changelog-new-release@v1
+#      with:
+#        changelogPath: Changelog.md
+#        version: ${{ steps.get_version.outputs.version-without-v }}
+
+#    # the release notes will be extracted from changelog 
+#    - name: Extract release notes
+#      id: extract-release-notes
+#      uses: ffurrer2/extract-release-notes@v1
+#      with:
+#          changelog_file: Changelog.md
+
+    # Releases should only be created on master by tagging the last commit.
+    # all artifacts in firmware folder pushed to the release
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.8
+      # Note:
+      # If you get the error "Resource not accessible by integration",
+      # The access rights are not sufficient, see
+      # https://github.com/softprops/action-gh-release/issues/232#issuecomment-1131379440
+      with:
+        name:  ${{ steps.get_version.outputs.version-without-v }}
+        body: ${{ steps.extract-release-notes.outputs.release_notes }}
+        files: |
+          release/*
+
+#    # Commit&Push Changelog to master branch. Must be manually merged back to rolling
+#    - name: Commit changes and push changes
+#      run: |
+#        git config user.name github-actions
+#        git config user.email github-actions@github.com
+#        git add Changelog.md
+#        git commit Changelog.md -m "Update Changelog.md for ${{github.event.inputs.versionIncrement}} release"
+#        git push origin HEAD:master
+
+
+#########################################################################################
+## Update the Web Installer on a release
+#########################################################################################
+# Make sure to also update update-webinstaller.yml!
+  update-web-installer:
+    if: github.event_name == 'release' && github.event.action == 'published' # Only run on release but not on prerelease
+    needs: [release]
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Get version of last release
+      id: last_release
+      uses: mindojo/get-latest-release@0b8ef1434d7468d6bffcc8263baff5c777f72321
+      with:
+        myToken: ${{ github.token }}
+        exclude_types: "draft|prerelease"
+        view_top: 1     
+
+    - name: Add binary to Web Installer and update manifest
+      run: |
+        echo "Updating Web installer to use firmware from ${{ steps.last_release.outputs.tag_name }}..."
+        rm -f docs/binary/firmware.bin
+        wget ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ steps.last_release.outputs.tag_name }}/AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        unzip AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        cp -f firmware.bin docs/binary/firmware.bin
+        echo "Updating index and manifest file..."
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/index.html
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v4
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v2
+      with:
+        path: 'docs'
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v3  # Note: v4 does not work!
--- a/.github/workflows/clear_cache.yaml
+++ b/.github/workflows/clear_cache.yaml
@@ -0,0 +1,30 @@
+name: Clear cache
+
+on:
+  workflow_dispatch:
+
+permissions:
+  actions: write
+
+jobs:
+  clear-cache:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clear cache
+        uses: actions/github-script@v6
+        with:
+          script: |
+            console.log("About to clear")
+            const caches = await github.rest.actions.getActionsCacheList({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            })
+            for (const cache of caches.data.actions_caches) {
+              console.log(cache)
+              github.rest.actions.deleteActionsCacheById({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                cache_id: cache.id,
+              })
+            }
+            console.log("Clear completed")
--- a/.github/workflows/manual-update-webinstaller.yaml
+++ b/.github/workflows/manual-update-webinstaller.yaml
@@ -0,0 +1,62 @@
+# This updates the Web Installer with the files from the docs folder and the binary of the latest release
+# it only gets run on:
+#  - Manually triggered
+# Make sure to also update the lower part of build.yml!
+
+name: Manual Web Installer Update
+
+on:
+  workflow_dispatch: # Run on manual trigger
+#  push:
+#    branches:
+#    - rolling
+#    paths:
+#    - docs # The path filter somehow does not work, so lets run it on every change to rolling
+
+jobs:
+  manually-update-web-installer:    
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Get version of last release
+      id: last_release
+      uses: mindojo/get-latest-release@0b8ef1434d7468d6bffcc8263baff5c777f72321
+      with:
+        myToken: ${{ github.token }}
+        exclude_types: "draft|prerelease"
+        view_top: 1     
+
+    - name: Add binary to Web Installer and update manifest
+      run: |
+        echo "Updating Web installer to use firmware from ${{ steps.last_release.outputs.tag_name }}..."
+        rm -f docs/binary/firmware.bin
+        wget https://github.com/jomjol/AI-on-the-edge-device/releases/download/${{ steps.last_release.outputs.tag_name }}/AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        unzip AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        cp -f firmware.bin docs/binary/firmware.bin
+        echo "Updating index and manifest file..."
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/index.html
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v2
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v1
+      with:
+        path: 'docs'
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v1   
--- a/.github/workflows/reply-bot.yaml
+++ b/.github/workflows/reply-bot.yaml
@@ -0,0 +1,79 @@
+# Reply Bot
+# It uses the configuration in .github/label-commenter-config.yaml
+# See https://github.com/peaceiris/actions-label-commenter
+
+name: Reply-Bot
+
+on:
+  issues:
+    types: [labeled]
+  discussion:
+    types: [labeled]
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+  discussions: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v4
+
+      ####################################################################
+      ## Remove labels again (issues only)
+      ## Make sure to also add the reply message to .github/label-commenter-config.yaml!
+      ## This currently seems no longer to work due to changes on the actions-cool/issues-helper!
+      ####################################################################
+#      - name: Remove 'Logfile' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Logfile'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Logfile'
+#          
+#      - name: Remove 'Web Console' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Web Console'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Web Console'
+#
+#      - name: Remove 'Properly Format Code' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Properly Format Code'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Properly Format Code'
+#          
+#      - name: Remove 'Web Installer' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Web Installer'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Web Installer'
+#
+#      - name: Remove 'Rolling Build' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Rolling Build'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Rolling Build'
+#          
+#      - name: Remove 'Show Trained Digits/Pointers' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Show Trained Digits/Pointers'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Show Trained Digits/Pointers'
+
+      ####################################################################
+      ## Write the response
+      ####################################################################
+      - name: Write Response
+        uses: peaceiris/actions-label-commenter@c2d00660c86f2b9ed0fb35b372c451558eba85b3
+        with:
+          github_token: "${{ secrets.GITHUB_TOKEN }}"
+          config_file: .github/label-commenter-config.yaml
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,13 @@
 .code-workspace
 /sd-card/htm./.vscode/
 /code/build
-
+/code/.helper
+/sd-card/html/debug/
+/firmware/
+version.txt
+/dist/
+/dist_release/
+/dist_old_ota
 CMakeLists.txt.user
 CMakeCache.txt
 CMakeFiles
@@ -15,3 +21,7 @@ install_manifest.txt
 compile_commands.json
 CTestTestfile.cmake
 _deps
+code/edgeAI.code-workspace
+.DS_Store
+tools/parameter-tooltip-generator/html
+tools/parameter-tooltip-generator/AI-on-the-edge-device-docs
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,12 @@
+[submodule "code/components/esp32-camera"]
+	path = code/components/esp32-camera
+	url = https://github.com/espressif/esp32-camera.git
+[submodule "code/components/esp-nn"]
+	path = code/components/esp-nn
+	url = https://github.com/espressif/esp-nn.git
+[submodule "code/components/esp-tflite-micro"]
+	path = code/components/esp-tflite-micro
+	url = https://github.com/espressif/esp-tflite-micro.git
+[submodule "code/components/stb"]
+	path = code/components/stb
+	url = https://github.com/nothings/stb.git
--- a/Changelog.md
+++ b/Changelog.md
--- a/FeatureRequest.md
+++ b/FeatureRequest.md
@@ -2,22 +2,183 @@

 **There are a lot of ideas for further improvements, but only limited capacity on side of the developer.** Therefore I have created this page as a collection of ideas. 

-1. Who ever has a new idea can put it here, so it that it is not forgotten. 
+1. Whoever has a new idea can put it here, so that it is not forgotten. 

-2. Who ever has time, capacity and passion to support, can take any of the ideas and implement them. 
-   I will support and help where ever I can!
+2. Whoever has the time, capacity and passion to support the project can take any of the ideas and implement them. I will provide support and help wherever I can!
   
   

 ____

-#### #14 Backup and restore option for configuration

-* https://github.com/jomjol/AI-on-the-edge-device/issues/459
+#### #40 Trigger with cron like exact time slot

-* Implement a zip file compression for store and restore
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2470

-* Update the html to handle it
+
+
+#### #39 upnp implementation to auto detect the device
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2481
+
+  
+
+#### #38 Energy Saving
+
+* Deep sleep between recognition
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2486
+
+
+
+#### #37 Auto init SD card
+
+* Fully implement the SD card handling (including formatting) into the firmware
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2488Demo 
+
+#### #36 Run demo without camera
+
+Demo mode requires a working camera (if not, one receives a 'Cam bad' error). Would be nice to demo or play around on other ESP32 boards (or on ESP32-CAM boards when you broke the camera cable...).
+
+#### #35 Use the same model, but provide the image from a Smartphone Camera
+as reading the Electricity or Water meter every few minutues only delivers apparent accuracy (DE: "Scheingenauigkeit") you could just as well take a picture with your Smartphone evey so often (e.g. once a week when you are in the Basement anyway), then with some "semi clever" tricks pass this image to the model developed here, and the values then on to who ever needs them e.g. via MQTT.
+IMO: It is not needed to have that many readings (datapoints) as our behaviour (Use of electricity or water) doesn't vary that much, say, over a weeks time. The interpolation between weekly readings will give sufficient information on the power and/or water usage. 
+
+
+#### #34 implement state and Roi for water leak detection
+for example see Roi on the next picture..
+![grafik](https://user-images.githubusercontent.com/38385805/207858812-2a6ba41d-1a8c-4fa1-9b6a-53cdd113c106.png)
+in case of position change between the measurments set this state to true, if there is no change set it back to false.
+In a defined time window this movement can lead into an alarm state / water leak..
+haveing this state in the mqtt broker can trigger functions like closing the ater pipe walve and so on...
+
+
+
+#### #33 Implement MATTER protocoll
+
+* see [#1404](https://github.com/jomjol/AI-on-the-edge-device/issues/1404)
+
+#### #32 Add feature to correct misinterpreted value
+
+* If a value is misinterpreted, the user can manually correct the value.
+* The misinterpreted ROIs would be saved in a "training data" -folder on the SD-card
+* Stretch goal: make sending of saved training data as easy as pushing a button =)
+
+#### #31 Implement InfluxDB v2.x interface
+
+* Currently only InfluxDB v1.x is supportet, extend to v2.x
+* Remark: interface has changed
+* see [#1160](https://github.com/jomjol/AI-on-the-edge-device/issues/1160)
+
+#### #30 Support meter clock over
+
+* In case of meter clocking over, that is, reaching its max. value and starting over from 0,
+  accept the new value and calculate correctly the difference.
+  (see line 739 onwards in ClassFlowPostProcessing.cpp)
+
+#### ~~#29 Add favicon and use the hostname for the website~~- implemented v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/927~~
+
+#### #28 Improved error handling for ROIs
+
+* In case a ROI is out of the image, there is no error message, but a non sense image is used
+* Implement a error message for wrong configuratioin of ROI
+
+#### #27 Use Homie Spec for Mqtt binding
+
+* Use the standardized Home Protocol for the Mqtt binding 
+* https://homieiot.github.io/
+
+#### #26 Changes behaviour for "N" replacement
+
+* in case the higher digits has already increased by minium 1 - don't set the "N" to the last value, but to "0"
+* https://github.com/jomjol/AI-on-the-edge-device/issues/792
+
+
+#### #25 Trigger Measurement via MQTT
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/727
+
+
+#### #24 Show Mqtt state directly in Webserver
+
+* Show MQTT log in Web page. E.g. connection established or failed to connect...
+
+  
+
+
+#### #23 CPU Temp and Mqtt values
+
+* Show the CPU Temp directly in Webpage. Also add the value to MQTT sending
+
+  
+
+#### ~~#22 Direct hint to the different neural network files in the other repositories~~- implemented >v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/644~~
+
+  
+
+#### #21 Extended "CheckDigitalConsistency" Logik
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/590
+
+  
+
+#### #20 Deep sleep and push mode
+
+* Let the device be normally in deep sleep state, and wake it up periodically to collect data and push it via MQTT or HTTP post.
+* Support ESP-NOW to reduce the overhead of connecting to wifi and mqtt 
+* the above should enable battery powered applications
+
+* An other way to set deep sleep would be to enable it in a specific period (at night).
+  
+
+#### #19 Extended log informations
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/580
+
+  
+
+#### ~~#18 Document WLAN-strength in web page~~
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/563~~
+
+
+
+#### ~~#17 Direct InfluxDB connection~~
+
+* ~~Done in v10.6.0~~
+
+
+#### #16 Serial Communication
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/512
+* Send the readout value via RX/TX interface with a dedicated TAG
+* Make dedicated communication FlowModule
+* Modification of RX/TX communication
+* Configuration interfache
+
+
+#### #15 Calibration for FishEye image
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/507
+
+1.  The development of such a correction algorithm with the libraries, that are available for the ESP32 environment.
+2. New module for integration of the flow into the image processing flow.
+3. Extension of the configuration (config.ini) and html-pages
+4. Parameter adjustment and testing for every different fish-eye module
+5. Maintenance for further updates / modules, ...
+
+
+
+#### ~~#14 Backup and restore option for configuration~~- implemented v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/459~~
+
+* ~~Implement a zip file compression for store and restore~~
+
+* ~~Update the html to handle it~~

  

@@ -29,9 +190,9 @@ ____

  

-#### #12 Less reboots due to memory leakage
+#### ~~#12 Less reboots due to memory leakage~~

-* Issue: #414 & #425  #430
+* ~~Issue: #414 & #425  #430~~

  

@@ -150,4 +311,4 @@ ____

 * ~~Implementation of a software module for external light source (e.g. WS8132 LED controller, ...)~~
 * ~~Update of the camera module to use the external light instead of the internal flash light~~
-* ~~Adopt the configuration algorithm with a configurable light source~~
+* ~~Adopt the configuration algorithm with a configurable light source~~
--- a/README.md
+++ b/README.md
@@ -1,137 +1,108 @@
-# AI-on-the-edge-device
+# Welcome to the AI-on-the-edge-device
+<img src="images/icon/watermeter.svg" width="100px">

-This is an example of Artificial Intelligence (AI) calculations on a very cheap hardware.
+Artificial intelligence based systems have become established in our everyday lives. Just think of speech or image recognition. Most of the systems rely on either powerful processors or a direct connection to the cloud for doing the calculations there. With the increasing power of modern processors, the AI systems are coming closer to the end user – which is usually called **edge computing**.
+Here, this edge computing is put into a practically oriented example, where an AI network is implemented on an ESP32 device so: **AI on the edge**.

-### Details on **function**, **installation** and **configuration** can be found on the **[Wiki Page](https://github.com/jomjol/AI-on-the-edge-device/wiki)**
+This project allows you to digitize your **analog** water, gas, power and other meters using cheap and easily available hardware.

-A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4573481
+All you need is an [ESP32 board with a supported camera](https://jomjol.github.io/AI-on-the-edge-device-docs/Hardware-Compatibility/) and something of a practical hand.

-or here https://www.thingiverse.com/thing:5028229
+<img src="images/esp32-cam.png" width="200px">

-respectively ESP32-Cam housing only: https://www.thingiverse.com/thing:4571627
+## Key features
+- Tensorflow Lite (TFlite) integration – including easy-to-use wrapper
+- Inline image processing (feature detection, alignment, ROI extraction)
+- **Small** and **cheap** device (3 x 4.5 x 2 cm³, < 10 EUR)
+- Integrated camera and illumination
+- Web interface for administration and control
+- OTA interface for updating directly via the web interface
+- Full integration into Homeassistant
+- Support for Influx DB 1 and 2
+- MQTT
+- REST API

+## Workflow
+The device takes a photo of your meter at a defined interval. It then extracts the Regions of Interest (ROIs) from the image and runs them through artificial intelligence. As a result, you get the digitized value of your meter.
+
+There are several options for what to do with that value. Either send it to an MQTT broker, write it to an InfluxDb or simply provide access to it via a REST API.
+
+<img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/idea.jpg" width="600"> 
+
+## Impressions
+### AI-on-the-edge-device on a Water Meter
 <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/watermeter_all.jpg" width="200"><img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/main.jpg" width="200"><img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/size.png" width="200"> 

+### Web Interface (Water Meter)
 <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/watermeter.jpg" width="600"> 

+### AI-on-the-edge-device on a Electrical Power Meter
 <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/powermeter.jpg" width="600"> 


+## Setup
+There is growing [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/) which provides you with a lot of information. Head there to get a start, set it up and configure it.

+There are also articles in the German Heise magazine "make:" about the setup and technical background (behind a paywall): [DIY - Setup](https://www.heise.de/select/make/2021/2/2103513300897420296)
+
+A lot of people created useful Youtube videos which might help you getting started.
+Here a small selection:
+
+- [youtube.com/watch?v=HKBofb1cnNc](https://www.youtube.com/watch?v=HKBofb1cnNc)
+- [youtube.com/watch?v=yyf0ORNLCk4](https://www.youtube.com/watch?v=yyf0ORNLCk4)
+- [youtube.com/watch?v=XxmTubGek6M](https://www.youtube.com/watch?v=XxmTubGek6M)
+- [youtube.com/watch?v=mDIJEyElkAU](https://www.youtube.com/watch?v=mDIJEyElkAU)
+- [youtube.com/watch?v=SssiPkyKVVs](https://www.youtube.com/watch?v=SssiPkyKVVs)
+- [youtube.com/watch?v=MAHE_QyHZFQ](https://www.youtube.com/watch?v=MAHE_QyHZFQ)
+- [youtube.com/watch?v=Uap_6bwtILQ](https://www.youtube.com/watch?v=Uap_6bwtILQ)
+
+For further background information, head to [Neural Networks](https://www.heise.de/select/make/2021/6/2126410443385102621), [Training Neural Networks](https://www.heise.de/select/make/2022/1/2134114065999161585) and [Programming on the ESP32](https://www.heise.de/select/make/2022/2/2204010051597422030).
+
+### Download
+The latest available version can be found on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).
+
+### Flashing the ESP32
+Initially you will have to flash the ESP32 via a USB connection. Later updates are possible directly over the air (OTA using WIFI).
+
+There are different ways to flash your ESP32:
+- The preferred way is the [Web Installer and Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) which is a browser-based tool to flash the ESP32 and extract the log over USB:
+![](images/web-installer.png)
+- Flash Tool from Espressif
+- ESPtool (command-line tool)
+
+See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/) for more information.
+
+### Flashing the SD Card
+The SD card can be setup automatically after the firmware got installed. See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#remote-setup-using-the-built-in-access-point) for details. For this to work, the SD card must be FAT formated (which is the default on a new SD card).
+Alternatively the SD card still can be setup manually, see the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#3-sd-card) for details!
+
+## Casing
+Various 3D-printable housing can be found here:
+  - https://www.thingiverse.com/thing:4573481 (Water Meter)
+  - https://www.thingiverse.com/thing:5028229 (Power Meter)
+  - https://www.thingiverse.com/thing:5224101 (Gas Meter)
+  - https://www.thingiverse.com/thing:4571627 (ESP32-cam housing only)

 ## Donate
+If you would like to support the developer with a cup of coffee, you can do that via [PayPal](https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL).

------
+<a href="https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL"><img border="0" src="images/paypal.png" width="200px" target="_blank"></a>

-If you would like to support the developer with a cup of coffee you can do that via [Paypal](https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL).
+## Support
+If you have any technical problems please search the [discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions). In case you found a ug or have a feature request, please open an [issue](https://github.com/jomjol/AI-on-the-edge-device/issues).

-<form action="https://www.paypal.com/donate" method="post" target="_top">
-<input type="hidden" name="hosted_button_id" value="8TRSVYNYKDSWL" />
-<input type="image" src="https://www.paypalobjects.com/en_US/DK/i/btn/btn_donateCC_LG.gif" border="0" name="submit" title="PayPal - The safer, easier way to pay online!" alt="Donate with PayPal button" />
-<img alt="" border="0" src="https://www.paypal.com/en_DE/i/scr/pixel.gif" width="1" height="1" />
-</form>
-If you have any technical topics, you can file a issue in this repository. 
+In other cases you can contact the developer via email: <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/mail.jpg" height="25">

-In other cases you can contact the developer via email: <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/mail.jpg" height="25"> 
+## Changes and History 
+See [Changelog](Changelog.md).

------
-## Coming next
+## Build It Yourself
+See [Build Instructions](code/README.md).

-* Automated update of the neural network file (tflite) to make the learing of additional pictures much easier and automated (GitHub action)
-* New "hyprid" neural network for digital numbers --> allowing the detection of intermediate states ("ring between two numbers") as a subdigit
-
-
------
-## Change log
-### Known Issues
-
-* slow response of web server during picture analysis
-* spontaneous reboots (mostly due to html access during image processing) - self recovery implemented
-
-**General remark:** Beside the `firmware.bin`, typically also the content of `/html` needs to be updated!
-
------
-
-##### 10.0.2 - Stability Increase (2022-01-01)
-
- NEW v10.0.2: Corrected JSON error
-
- Updated compiler toolchain to ESP-IDF 4.3
-
- Removal of memory leak
-
- Improved error handling during startup (check PSRAM and camera with remark in logfile)
-
- MQTT: implemented raw value additionally, removal of regex contrain
-
- Normalized Parameter ``MaxRateValue``  to "change per minute" 
-
- HTML: improved input handling
-
- Corrected error handling: in case of error the old value, rate, timestamp are not transmitted any more
-
-  
-
-##### 9.2.0 - External Illumination (2021-12-02)
-
- Direct JSON access: ``http://IP-ADRESS/json`` 
- Error message in log file in case camera error during startup
- Upgrade analog CNN to v9.1.0
- Upgrade digital CNN to v13.3.0 (added new images)
- html: support of different ports
-
-##### 9.1.1 - External Illumination (2021-11-16)
-
- NEW 9.1.1 bug fix: LED implemenetation
- External LEDs: change control mode (resolve bug with more than 2 LEDs)
- Additional info into log file
- Bug fix: decimal shift, html, log file
-
-##### 9.0.0 - External Illumination (2021-10-23)
-
-* Implementation of external illumination to adjust positioning, brightness and color of the illumination now individually
-  * Technical details can be found in the wiki: https://github.com/jomjol/AI-on-the-edge-device/wiki/External-LED
-  <img src="https://raw.githubusercontent.com/jomjol/ai-on-the-edge-device/master/images/intern_vs_external.jpg" width="500">
-* New housing published for external LEDs and small clearing: https://www.thingiverse.com/thing:5028229
-
-
-
-
-
-
-## Additional ideas
-
-There are some ideas and feature request, which are not followed currently - mainly due to capacity reasons on side of the developer. They are collected here: [FeatureRequest.md](FeatureRequest.md)
-
-
-
------
-
-## History
-
-##### 8.5.0 - Multi Meter Support (2021-10-07)
-
-##### 7.1.2 MQTT-Update - (2021-06-17)
-
-##### 6.7.2 Image Processing in Memory - (2021-05-01)
-
-##### 5.0.0 Setup Modus - (2020-12-06)
-
-##### 4.1.1 Configuration editor - (2020-12-02)
-
-##### 4.0.0 Tflite Core - (2020-11-15)
-##### 3.1.0 MQTT-Client - (2020-10-26)
-
-##### 2.2.1 Version Control - (2020-09-27)
-
-
-##### 2.1.0 Decimal Shift, Chrome & Edge - (2020-09-25)
-
-
-##### 2.0.0 Layout update - (2020-09-12)
-
-##### 1.1.3 Initial Version - (2020-09-09)
-
-
-#### [Full Changelog](Changelog.md)
+## Tools
+* Logfile downloader and combiner (Thx to [reserve85](https://github.com/reserve85))
+  * Files see ['/tools/logfile-tool'](tbd), how-to see [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/outdated--Gasmeter-Log-Downloader/)

+## Additional Ideas
+There are some ideas and feature requests which are not currently being pursued – mainly due to capacity reasons on the part of the developers.
+They features are collected in the [issues](https://github.com/jomjol/AI-on-the-edge-device/issues) and in [FeatureRequest.md](FeatureRequest.md).
--- a/code/.gitignore
+++ b/code/.gitignore
@@ -1,5 +1,16 @@
 .pio
+.idea
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/ipch
+version.cpp
+sdkconfig.esp32cam
+sdkconfig.esp32cam-dev
+sdkconfig.esp32cam-debug
+sdkconfig.esp32cam-board-rev3
+sdkconfig.esp32cam-cpu-freq-240
+sdkconfig.esp32cam-board-rev3-cpu-freq-240
+sdkconfig.esp32cam-dev-himem
+sdkconfig.esp32cam-dev-task-analysis
+sdkconfig.esp32cam-no-softap
--- a/code/.helper/copy-esp-idf.bat
+++ b/code/.helper/copy-esp-idf.bat
@@ -1,3 +0,0 @@
-copy "..\..\code\build\esp32cam-server-only.bin" "..\..\firmware\firmware.bin"
-copy "..\..\code\build\bootloader\bootloader.bin" "..\..\firmware\bootloader.bin"
-copy "..\..\code\build\partition_table\partition-table.bin" "..\..\firmware\partitions.bin"
--- a/code/.helper/makezip.bat
+++ b/code/.helper/makezip.bat
@@ -1 +1 @@
-powershell Compress-Archive "..\..\sd-card\html\*.*" "..\..\firmware\html.zip"
+powershell Compress-Archive -Path "..\..\sd-card\html\*.*" -DestinationPath "..\..\firmware\html.zip"
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1,8 +1,6 @@
-cmake_minimum_required(VERSION 3.13.4)
+cmake_minimum_required(VERSION 3.16.0)

-list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
-
-set(PROJECT_VER "0.0.9.3")
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common components/esp-tflite-micro)

 ADD_CUSTOM_COMMAND(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/version.cpp
@@ -10,6 +8,15 @@ ADD_CUSTOM_COMMAND(
    COMMAND ${CMAKE_COMMAND} -P
            ${CMAKE_CURRENT_SOURCE_DIR}/version.cmake)

+if(EXISTS "${SDKCONFIG}.defaults")
+    if(EXISTS "sdkconfig.defaults")
+        set(SDKCONFIG_DEFAULTS "${SDKCONFIG}.defaults;sdkconfig.defaults")
+        message(STATUS "-- Using defaults: ${SDKCONFIG_DEFAULTS} + sdkconfig.defaults")
+    else()
+        set(SDKCONFIG_DEFAULTS "${SDKCONFIG}.defaults")
+    endif()
+    message(STATUS "-- Using defaults: ${SDKCONFIG_DEFAULTS}")
+endif()

 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(esp32cam-server-only)
+project(AI-on-the-edge)
--- a/code/README.md
+++ b/code/README.md
@@ -0,0 +1,74 @@
+# Build
+
+## Preparations
+```
+git clone https://github.com/jomjol/AI-on-the-edge-device.git
+cd AI-on-the-edge-device
+git checkout rolling
+git submodule update --init
+```
+
+## Update Submodules
+```
+cd /components/submodule-name (e.g. tflite-micro-example)
+git checkout VERSION (e.g. HASH of latest tflite-micro-example build)
+cd ../../ (auf Ebene von code)
+git submodule update --init
+```
+Evt. muss man vorher noch einige Verzeichnisse in compenents von Hand löschen, da sie beim checkout nicht gelöscht wurden (vor update -- init)
+
+## Build and Flash within terminal
+See further down to build it within an IDE.
+### Compile
+```
+cd code
+platformio run --environment esp32cam
+```
+
+### Upload
+```
+pio run --target upload --upload-port /dev/ttyUSB0
+```
+
+Alternatively you also can set the UART device in `platformio.ini`, eg. `upload_port = /dev/ttyUSB0`
+
+### Monitor UART Log
+```
+pio device monitor -p /dev/ttyUSB0
+```
+
+## Build and Flash with Visual Code IDE
+
+- Download and install VS Code
+  - https://code.visualstudio.com/Download
+- Install the VS Code platform io plugin
+  - <img src="https://raw.githubusercontent.com/jomjol/ai-on-the-edge-device/master/images/platformio_plugin.jpg" width="200" align="middle">
+  - Check for error messages, maybe you need to manually add some python libraries
+    - e.g. in my Ubuntu a python3-env was missing: `sudo apt-get install python3-venv`
+- git clone this project
+  - in Linux: 
+
+    ```
+    git clone https://github.com/jomjol/AI-on-the-edge-device.git
+    cd AI-on-the-edge-device
+    git checkout rolling
+    git submodule update --init
+    ```
+
+- in VS code, open the `AI-on-the-edge-device/code` 
+	- from terminal: `cd AI-on-the-edge-device/code && code .`
+- open a pio terminal (click on the terminal sign in the bottom menu bar)
+- make sure you are in the `code` directory
+- To build, type  `platformio run --environment esp32cam`
+  - or use the graphical interface:
+    <img src="https://raw.githubusercontent.com/jomjol/ai-on-the-edge-device/master/images/platformio_build.jpg" width="200" align="middle">
+  - the build artifacts are stored in  `code/.pio/build/esp32cam/`
+- Connect the device and type `pio device monitor`. There you will see your device and can copy the name to the next instruction
+- Add `upload_port = you_device_port` to the `platformio.ini` file
+- make sure an sd card with the contents of the `sd_card` folder is inserted and you have changed the wifi details
+- `pio run --target erase` to erase the flash
+- `pio run --target upload` this will upload the `bootloader.bin, partitions.bin,firmware.bin` from the `code/.pio/build/esp32cam/` folder. 
+- `pio device monitor` to observe the logs via uart
+
+# Update Parameters
+If you create or rename a parameter, make sure to update its documentation in `../param-docs/parameter-pages`! Check the `../param-docs/README.md` for more information.
--- a/code/components/esp-nn
+++ b/code/components/esp-nn
--- a/code/components/esp-tflite-micro
+++ b/code/components/esp-tflite-micro
--- a/code/components/esp32-camera
+++ b/code/components/esp32-camera
--- a/code/components/esp32-camera-master/.gitignore
+++ b/code/components/esp32-camera-master/.gitignore
@@ -1 +0,0 @@
-*.DS_Store
--- a/code/components/esp32-camera-master/CMakeLists.txt
+++ b/code/components/esp32-camera-master/CMakeLists.txt
@@ -1,35 +0,0 @@
-if(IDF_TARGET STREQUAL "esp32")
-  set(COMPONENT_SRCS
-    driver/camera.c
-    driver/sccb.c
-    driver/sensor.c
-    driver/xclk.c
-    sensors/ov2640.c
-    sensors/ov3660.c
-    sensors/ov5640.c
-    sensors/ov7725.c
-    sensors/ov7670.c
-    sensors/nt99141.c
-    conversions/yuv.c
-    conversions/to_jpg.cpp
-    conversions/to_bmp.c
-    conversions/jpge.cpp
-    conversions/esp_jpg_decode.c
-    )
-
-  set(COMPONENT_ADD_INCLUDEDIRS
-    driver/include
-    conversions/include
-    )
-
-  set(COMPONENT_PRIV_INCLUDEDIRS
-    driver/private_include
-    sensors/private_include
-    conversions/private_include
-    )
-
-  set(COMPONENT_REQUIRES driver)
-  set(COMPONENT_PRIV_REQUIRES freertos nvs_flash)
-
-  register_component()
-endif()
--- a/code/components/esp32-camera-master/Kconfig
+++ b/code/components/esp32-camera-master/Kconfig
@@ -1,71 +0,0 @@
-menu "Camera configuration"
-
-    config OV7670_SUPPORT
-        bool "Support OV7670 VGA"
-        default y
-        help
-            Enable this option if you want to use the OV7670.
-            Disable this option to safe memory.
-
-    config OV7725_SUPPORT
-        bool "Support OV7725 SVGA"
-        default n
-        help
-            Enable this option if you want to use the OV7725.
-            Disable this option to save memory.
-
-    config NT99141_SUPPORT
-        bool "Support NT99141 HD"
-        default y
-        help
-            Enable this option if you want to use the NT99141.
-            Disable this option to save memory.
-
-    config OV2640_SUPPORT
-        bool "Support OV2640 2MP"
-        default y
-        help
-            Enable this option if you want to use the OV2640.
-            Disable this option to save memory.
-
-    config OV3660_SUPPORT
-        bool "Support OV3660 3MP"
-        default y
-        help
-            Enable this option if you want to use the OV3360.
-            Disable this option to save memory.
-
-    config OV5640_SUPPORT
-        bool "Support OV5640 5MP"
-        default y
-        help
-            Enable this option if you want to use the OV5640.
-            Disable this option to save memory.
-
-    choice SCCB_HARDWARE_I2C_PORT
-        bool "I2C peripheral to use for SCCB"
-        default SCCB_HARDWARE_I2C_PORT1
-
-        config SCCB_HARDWARE_I2C_PORT0
-            bool "I2C0"
-        config SCCB_HARDWARE_I2C_PORT1
-            bool "I2C1"
-
-    endchoice
-
-    choice CAMERA_TASK_PINNED_TO_CORE
-        bool "Camera task pinned to core"
-        default CAMERA_CORE0
-        help
-            Pin the camera handle task to a certain core(0/1). It can also be done automatically choosing NO_AFFINITY.
-
-        config CAMERA_CORE0
-            bool "CORE0"
-        config CAMERA_CORE1
-            bool "CORE1"
-        config CAMERA_NO_AFFINITY
-            bool "NO_AFFINITY"
-
-    endchoice
-
-endmenu
--- a/code/components/esp32-camera-master/LICENSE
+++ b/code/components/esp32-camera-master/LICENSE
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/code/components/esp32-camera-master/README.md
+++ b/code/components/esp32-camera-master/README.md
@@ -1,358 +0,0 @@
-# ESP32 Camera Driver
-
-## General Information
-
-This repository hosts ESP32 compatible driver for OV2640, OV3660, OV5640, OV7670 and OV7725 image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
-
-## Important to Remember
-
- Except when using CIF or lower resolution with JPEG, the driver requires PSRAM to be installed and activated.
- Using YUV or RGB puts a lot of strain on the chip because writing to PSRAM is not particularly fast. The result is that image data might be missing. This is particularly true if WiFi is enabled. If you need RGB data, it is recommended that JPEG is captured and then turned into RGB using `fmt2rgb888` or `fmt2bmp`/`frame2bmp`.
- When 1 frame buffer is used, the driver will wait for the current frame to finish (VSYNC) and start I2S DMA. After the frame is acquired, I2S will be stopped and the frame buffer returned to the application. This approach gives more control over the system, but results in longer time to get the frame.
- When 2 or more frame bufers are used, I2S is running in continuous mode and each frame is pushed to a queue that the application can access. This approach puts more strain on the CPU/Memory, but allows for double the frame rate. Please use only with JPEG.
-
-## Installation Instructions
-
-
-### Using esp-idf
-
- Clone or download and extract the repository to the components folder of your ESP-IDF project
- Enable PSRAM in `menuconfig`
- Include `esp_camera.h` in your code
-
-### Using PlatformIO
-
-The easy way -- on the `env` section of `platformio.ini`, add the following:
-
-```ini
-[env]
-lib_deps =
-  esp32-camera
-```
-
-Now the `esp_camera.h` is available to be included:
-
-```c
-#include "esp_camera.h"
-```
-
-Enable PSRAM on `menuconfig` or type it direclty on `sdkconfig`. Check the [official doc](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-esp32-spiram-support) for more info.
-
-```
-CONFIG_ESP32_SPIRAM_SUPPORT=y
-```
-
-***Arduino*** The easy-way (content above) only seems to work if you're using `framework=arduino` which seems to take a bunch of the guesswork out (thanks Arduino!) but also suck up a lot more memory and flash, almost crippling the performance.  If you plan to use the `framework=espidf` then read the sections below carefully!!
-
-## Platform.io lib/submodule (for framework=espidf)
-
-It's probably easier to just skip the platform.io library registry version and link the git repo as a submodule. (i.e. using code outside the platform.io library management). In this example we will install this as a submodule inside the platform.io $project/lib folder: 
-```
-cd $project\lib
-git submodule add -b master https://github.com/espressif/esp32-camera.git
-```
-
-Then in `platformio.ini` file
-```
-build_flags =
-   -I../lib/esp32-camera
-```
-After that `#include "esp_camera.h"` statement will be available. Now the module is included, and you're hopefully back to the same place as the easy-Arduino way. 
-
-**Warning about platform.io/espidf and fresh (not initialized) git repos**
-There is a sharp-edge on you'll discover in the platform.io build process (in espidf v3.3 & 4.0.1) where a project which has only had `git init`  but nothing committed will crash platform.io build process with highly non-useful output.  The cause is due to lack of a version (making you think you did something wrong, when you didn't at all) - the output is horribly non-descript.  Solution: the devs want you to create a file called version.txt with a number in it, or simply commit any file to the projects git repo and use git. This happens because platform.io build process tries to be too clever and determine the build version number from the git repo - it's a sharp edge you'll only encounter if you're experimenting on a new project with no commits .. like wtf is my camera not working let's try a 'clean project'?!  </rant> 
-
-## Platform.io Kconfig 
-Kconfig is used by the platform.io menuconfig (accessed by running: `pio run -t menuconfig`) to interactively manage the various #ifdef statements throughout the espidf and supporting libraries (i.e. this repo: esp32-camera and arduino-esp32.git).  The menuconfig process generates the `sdkconfig` file which is ultimately used behind the scenes by espidf compile+build process. 
-
-**Make sure to append or symlink** [this `Kconfig`](./Kconfig) content into the `Kconfig` of your project. 
-
-You symlink (or copy) the included Kconfig into your platform.io projects src directory.  The file should be named `Kconfig.projbuild` in your projects src\ directory or you could also add the library path to a CMakefile.txt and hope the `Kconfig` (or `Kconfig.projbuild`) gets discovered by the menuconfig process, though this unpredictable for me. 
-
-The unpredictable wonky behavior in platform.io build process around Kconfig naming (Kconfig vs. Kconfig.projbuild) occurs between espidf versions 3.3 and 4.0 - but if you don't see "Camera configuration" in your `pio run -t menuconfig` then there is no point trying to test camera code (it may compile, but it probably won't work!) and it seems the platform.io devs (when they built their wrapper around the espidf menuconfig) didn't implement it properly.  You've probably already figured out you can't use the espidf build tools since the files are in totally different locations and also different versions with sometimes different syntax.   This is one of those times you might consider changing the `platformio.ini` from `platform=espressif32` to `platform=https://github.com/platformio/platform-espressif32.git#develop` to get a more recent version of the espidf 4.0 tools. 
-
-However with a bit of patience and experimenting you'll figure the Kconfig out. Once Kconfig (or Kconfig.projbuild) is working then you will be able to choose the configurations according to your setup or the camera libraries will be compiled.  Although you might also need to delete your .pio/build directory before the options appear .. again, the `pio run -t menuconfig` doens't always notice the new Kconfig files! 
-
-If you miss-skip-ignore this critical step the camera module will compile but camera logic inside the library will be 'empty' because the Kconfig sets the proper #ifdef statements during the build process to initialize the selected cameras.  It's very not optional! 
-
-### Kconfig options
-
-| config                            | description                                                                                                                                                  | default                        |
-| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------ |
-| CONFIG_OV2640_SUPPORT             | Support for OV2640 camera                                                                                                                                    | enabled                        |
-| CONFIG_OV7725_SUPPORT             | Support for OV7725 camera                                                                                                                                    | disabled                       |
-| CONFIG_OV3660_SUPPORT             | Support for OV3660 camera                                                                                                                                    | enabled                        |
-| CONFIG_OV5640_SUPPORT             | Support for OV5640 camera                                                                                                                                    | enabled                        |
-| CONFIG_SCCB_HARDWARE_I2C          | Enable this option if you want to use hardware I2C to control the camera. Disable this option to use software I2C.                                           | enabled                        |
-| CONFIG_SCCB_HARDWARE_I2C_PORT     | I2C peripheral to use for SCCB. Can be I2C0 and I2C1.                                                                                                        | CONFIG_SCCB_HARDWARE_I2C_PORT1 |
-| CONFIG_CAMERA_TASK_PINNED_TO_CORE | Pin the camera handle task to a certain core(0/1). It can also be done automatically choosing NO_AFFINITY. Can be CAMERA_CORE0, CAMERA_CORE1 or NO_AFFINITY. | CONFIG_CAMERA_CORE0            |
-
-## Examples
-
-### Initialization
-
-```c
-#include "esp_camera.h"
-
-//WROVER-KIT PIN Map
-#define CAM_PIN_PWDN    -1 //power down is not used
-#define CAM_PIN_RESET   -1 //software reset will be performed
-#define CAM_PIN_XCLK    21
-#define CAM_PIN_SIOD    26
-#define CAM_PIN_SIOC    27
-
-#define CAM_PIN_D7      35
-#define CAM_PIN_D6      34
-#define CAM_PIN_D5      39
-#define CAM_PIN_D4      36
-#define CAM_PIN_D3      19
-#define CAM_PIN_D2      18
-#define CAM_PIN_D1       5
-#define CAM_PIN_D0       4
-#define CAM_PIN_VSYNC   25
-#define CAM_PIN_HREF    23
-#define CAM_PIN_PCLK    22
-
-static camera_config_t camera_config = {
-    .pin_pwdn  = CAM_PIN_PWDN,
-    .pin_reset = CAM_PIN_RESET,
-    .pin_xclk = CAM_PIN_XCLK,
-    .pin_sscb_sda = CAM_PIN_SIOD,
-    .pin_sscb_scl = CAM_PIN_SIOC,
-
-    .pin_d7 = CAM_PIN_D7,
-    .pin_d6 = CAM_PIN_D6,
-    .pin_d5 = CAM_PIN_D5,
-    .pin_d4 = CAM_PIN_D4,
-    .pin_d3 = CAM_PIN_D3,
-    .pin_d2 = CAM_PIN_D2,
-    .pin_d1 = CAM_PIN_D1,
-    .pin_d0 = CAM_PIN_D0,
-    .pin_vsync = CAM_PIN_VSYNC,
-    .pin_href = CAM_PIN_HREF,
-    .pin_pclk = CAM_PIN_PCLK,
-
-    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
-    .xclk_freq_hz = 20000000,
-    .ledc_timer = LEDC_TIMER_0,
-    .ledc_channel = LEDC_CHANNEL_0,
-
-    .pixel_format = PIXFORMAT_JPEG,//YUV422,GRAYSCALE,RGB565,JPEG
-    .frame_size = FRAMESIZE_UXGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG
-
-    .jpeg_quality = 12, //0-63 lower number means higher quality
-    .fb_count = 1 //if more than one, i2s runs in continuous mode. Use only with JPEG
-};
-
-esp_err_t camera_init(){
-    //power up the camera if PWDN pin is defined
-    if(CAM_PIN_PWDN != -1){
-        pinMode(CAM_PIN_PWDN, OUTPUT);
-        digitalWrite(CAM_PIN_PWDN, LOW);
-    }
-
-    //initialize the camera
-    esp_err_t err = esp_camera_init(&camera_config);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "Camera Init Failed");
-        return err;
-    }
-
-    return ESP_OK;
-}
-
-esp_err_t camera_capture(){
-    //acquire a frame
-    camera_fb_t * fb = esp_camera_fb_get();
-    if (!fb) {
-        ESP_LOGE(TAG, "Camera Capture Failed");
-        return ESP_FAIL;
-    }
-    //replace this with your own function
-    process_image(fb->width, fb->height, fb->format, fb->buf, fb->len);
-  
-    //return the frame buffer back to the driver for reuse
-    esp_camera_fb_return(fb);
-    return ESP_OK;
-}
-```
-
-### JPEG HTTP Capture
-
-```c
-#include "esp_camera.h"
-#include "esp_http_server.h"
-#include "esp_timer.h"
-
-typedef struct {
-        httpd_req_t *req;
-        size_t len;
-} jpg_chunking_t;
-
-static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
-    jpg_chunking_t *j = (jpg_chunking_t *)arg;
-    if(!index){
-        j->len = 0;
-    }
-    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
-        return 0;
-    }
-    j->len += len;
-    return len;
-}
-
-esp_err_t jpg_httpd_handler(httpd_req_t *req){
-    camera_fb_t * fb = NULL;
-    esp_err_t res = ESP_OK;
-    size_t fb_len = 0;
-    int64_t fr_start = esp_timer_get_time();
-
-    fb = esp_camera_fb_get();
-    if (!fb) {
-        ESP_LOGE(TAG, "Camera capture failed");
-        httpd_resp_send_500(req);
-        return ESP_FAIL;
-    }
-    res = httpd_resp_set_type(req, "image/jpeg");
-    if(res == ESP_OK){
-        res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
-    }
-
-    if(res == ESP_OK){
-        if(fb->format == PIXFORMAT_JPEG){
-            fb_len = fb->len;
-            res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
-        } else {
-            jpg_chunking_t jchunk = {req, 0};
-            res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
-            httpd_resp_send_chunk(req, NULL, 0);
-            fb_len = jchunk.len;
-        }
-    }
-    esp_camera_fb_return(fb);
-    int64_t fr_end = esp_timer_get_time();
-    ESP_LOGI(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
-    return res;
-}
-```
-
-### JPEG HTTP Stream
-
-```c
-#include "esp_camera.h"
-#include "esp_http_server.h"
-#include "esp_timer.h"
-
-#define PART_BOUNDARY "123456789000000000000987654321"
-static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
-static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
-static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
-
-esp_err_t jpg_stream_httpd_handler(httpd_req_t *req){
-    camera_fb_t * fb = NULL;
-    esp_err_t res = ESP_OK;
-    size_t _jpg_buf_len;
-    uint8_t * _jpg_buf;
-    char * part_buf[64];
-    static int64_t last_frame = 0;
-    if(!last_frame) {
-        last_frame = esp_timer_get_time();
-    }
-
-    res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
-    if(res != ESP_OK){
-        return res;
-    }
-
-    while(true){
-        fb = esp_camera_fb_get();
-        if (!fb) {
-            ESP_LOGE(TAG, "Camera capture failed");
-            res = ESP_FAIL;
-            break;
-        }
-        if(fb->format != PIXFORMAT_JPEG){
-            bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
-            if(!jpeg_converted){
-                ESP_LOGE(TAG, "JPEG compression failed");
-                esp_camera_fb_return(fb);
-                res = ESP_FAIL;
-            }
-        } else {
-            _jpg_buf_len = fb->len;
-            _jpg_buf = fb->buf;
-        }
-
-        if(res == ESP_OK){
-            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
-        }
-        if(res == ESP_OK){
-            size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
-
-            res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
-        }
-        if(res == ESP_OK){
-            res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
-        }
-        if(fb->format != PIXFORMAT_JPEG){
-            free(_jpg_buf);
-        }
-        esp_camera_fb_return(fb);
-        if(res != ESP_OK){
-            break;
-        }
-        int64_t fr_end = esp_timer_get_time();
-        int64_t frame_time = fr_end - last_frame;
-        last_frame = fr_end;
-        frame_time /= 1000;
-        ESP_LOGI(TAG, "MJPG: %uKB %ums (%.1ffps)",
-            (uint32_t)(_jpg_buf_len/1024),
-            (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
-    }
-
-    last_frame = 0;
-    return res;
-}
-```
-
-### BMP HTTP Capture
-
-```c
-#include "esp_camera.h"
-#include "esp_http_server.h"
-#include "esp_timer.h"
-
-esp_err_t bmp_httpd_handler(httpd_req_t *req){
-    camera_fb_t * fb = NULL;
-    esp_err_t res = ESP_OK;
-    int64_t fr_start = esp_timer_get_time();
-
-    fb = esp_camera_fb_get();
-    if (!fb) {
-        ESP_LOGE(TAG, "Camera capture failed");
-        httpd_resp_send_500(req);
-        return ESP_FAIL;
-    }
-
-    uint8_t * buf = NULL;
-    size_t buf_len = 0;
-    bool converted = frame2bmp(fb, &buf, &buf_len);
-    esp_camera_fb_return(fb);
-    if(!converted){
-        ESP_LOGE(TAG, "BMP conversion failed");
-        httpd_resp_send_500(req);
-        return ESP_FAIL;
-    }
-
-    res = httpd_resp_set_type(req, "image/x-windows-bmp")
-       || httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.bmp")
-       || httpd_resp_send(req, (const char *)buf, buf_len);
-    free(buf);
-    int64_t fr_end = esp_timer_get_time();
-    ESP_LOGI(TAG, "BMP: %uKB %ums", (uint32_t)(buf_len/1024), (uint32_t)((fr_end - fr_start)/1000));
-    return res;
-}
-```
-
-
-
--- a/code/components/esp32-camera-master/component.mk
+++ b/code/components/esp32-camera-master/component.mk
@@ -1,4 +0,0 @@
-COMPONENT_ADD_INCLUDEDIRS := driver/include conversions/include
-COMPONENT_PRIV_INCLUDEDIRS := driver/private_include conversions/private_include sensors/private_include
-COMPONENT_SRCDIRS := driver conversions sensors
-CXXFLAGS += -fno-rtti
--- a/code/components/esp32-camera-master/conversions/esp_jpg_decode.c
+++ b/code/components/esp32-camera-master/conversions/esp_jpg_decode.c
@@ -1,128 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "esp_jpg_decode.h"
-
-#include "esp_system.h"
-#if ESP_IDF_VERSION_MAJOR >= 4 // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/tjpgd.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/tjpgd.h"
-#endif
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#define TAG ""
-#else
-#include "esp_log.h"
-static const char* TAG = "esp_jpg_decode";
-#endif
-
-typedef struct {
-        jpg_scale_t scale;
-        jpg_reader_cb reader;
-        jpg_writer_cb writer;
-        void * arg;
-        size_t len;
-        size_t index;
-} esp_jpg_decoder_t;
-
-static const char * jd_errors[] = {
-    "Succeeded",
-    "Interrupted by output function",
-    "Device error or wrong termination of input stream",
-    "Insufficient memory pool for the image",
-    "Insufficient stream input buffer",
-    "Parameter error",
-    "Data format error",
-    "Right format but not supported",
-    "Not supported JPEG standard"
-};
-
-static uint32_t _jpg_write(JDEC *decoder, void *bitmap, JRECT *rect)
-{
-    uint16_t x = rect->left;
-    uint16_t y = rect->top;
-    uint16_t w = rect->right + 1 - x;
-    uint16_t h = rect->bottom + 1 - y;
-    uint8_t *data = (uint8_t *)bitmap;
-
-    esp_jpg_decoder_t * jpeg = (esp_jpg_decoder_t *)decoder->device;
-
-    if (jpeg->writer) {
-        return jpeg->writer(jpeg->arg, x, y, w, h, data);
-    }
-    return 0;
-}
-
-static uint32_t _jpg_read(JDEC *decoder, uint8_t *buf, uint32_t len)
-{
-    esp_jpg_decoder_t * jpeg = (esp_jpg_decoder_t *)decoder->device;
-    if (jpeg->len && len > (jpeg->len - jpeg->index)) {
-        len = jpeg->len - jpeg->index;
-    }
-    if (len) {
-        len = jpeg->reader(jpeg->arg, jpeg->index, buf, len);
-        if (!len) {
-            ESP_LOGE(TAG, "Read Fail at %u/%u", jpeg->index, jpeg->len);
-        }
-        jpeg->index += len;
-    }
-    return len;
-}
-
-esp_err_t esp_jpg_decode(size_t len, jpg_scale_t scale, jpg_reader_cb reader, jpg_writer_cb writer, void * arg)
-{
-    static uint8_t work[3100];
-    JDEC decoder;
-    esp_jpg_decoder_t jpeg;
-
-    jpeg.len = len;
-    jpeg.reader = reader;
-    jpeg.writer = writer;
-    jpeg.arg = arg;
-    jpeg.scale = scale;
-    jpeg.index = 0;
-
-    JRESULT jres = jd_prepare(&decoder, _jpg_read, work, 3100, &jpeg);
-    if(jres != JDR_OK){
-        ESP_LOGE(TAG, "JPG Header Parse Failed! %s", jd_errors[jres]);
-        return ESP_FAIL;
-    }
-
-    uint16_t output_width = decoder.width / (1 << (uint8_t)(jpeg.scale));
-    uint16_t output_height = decoder.height / (1 << (uint8_t)(jpeg.scale));
-
-    //output start
-    writer(arg, 0, 0, output_width, output_height, NULL);
-    //output write
-    jres = jd_decomp(&decoder, _jpg_write, (uint8_t)jpeg.scale);
-    //output end
-    writer(arg, output_width, output_height, output_width, output_height, NULL);
-
-    if (jres != JDR_OK) {
-        ESP_LOGE(TAG, "JPG Decompression Failed! %s", jd_errors[jres]);
-        return ESP_FAIL;
-    }
-    //check if all data has been consumed.
-    if (len && jpeg.index < len) {
-        _jpg_read(&decoder, NULL, len - jpeg.index);
-    }
-
-    return ESP_OK;
-}
-
--- a/code/components/esp32-camera-master/conversions/include/esp_jpg_decode.h
+++ b/code/components/esp32-camera-master/conversions/include/esp_jpg_decode.h
@@ -1,43 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _ESP_JPG_DECODE_H_
-#define _ESP_JPG_DECODE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_err.h"
-
-typedef enum {
-    JPG_SCALE_NONE,
-    JPG_SCALE_2X,
-    JPG_SCALE_4X,
-    JPG_SCALE_8X,
-    JPG_SCALE_MAX = JPG_SCALE_8X
-} jpg_scale_t;
-
-typedef size_t (* jpg_reader_cb)(void * arg, size_t index, uint8_t *buf, size_t len);
-typedef bool (* jpg_writer_cb)(void * arg, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t *data);
-
-esp_err_t esp_jpg_decode(size_t len, jpg_scale_t scale, jpg_reader_cb reader, jpg_writer_cb writer, void * arg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ESP_JPG_DECODE_H_ */
--- a/code/components/esp32-camera-master/conversions/include/img_converters.h
+++ b/code/components/esp32-camera-master/conversions/include/img_converters.h
@@ -1,127 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _IMG_CONVERTERS_H_
-#define _IMG_CONVERTERS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_camera.h"
-
-typedef size_t (* jpg_out_cb)(void * arg, size_t index, const void* data, size_t len);
-
-/**
- * @brief Convert image buffer to JPEG
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool fmt2jpg_cb(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert camera frame buffer to JPEG
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool frame2jpg_cb(camera_fb_t * fb, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert image buffer to JPEG buffer
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer.
- *                  You MUST free the pointer once you are done with it.
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2jpg(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to JPEG buffer
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2jpg(camera_fb_t * fb, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to BMP buffer
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2bmp(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to BMP buffer
- *
- * @param fb        Source camera frame buffer
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2bmp(camera_fb_t * fb, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to RGB888 buffer (used for face detection)
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param format    Format of the source image
- * @param rgb_buf   Pointer to the output buffer (width * height * 3)
- *
- * @return true on success
- */
-bool fmt2rgb888(const uint8_t *src_buf, size_t src_len, pixformat_t format, uint8_t * rgb_buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _IMG_CONVERTERS_H_ */
--- a/code/components/esp32-camera-master/conversions/jpge.cpp
+++ b/code/components/esp32-camera-master/conversions/jpge.cpp
@@ -1,723 +0,0 @@
-// jpge.cpp - C++ class for JPEG compression.
-// Public domain, Rich Geldreich <richgel99@gmail.com>
-// v1.01, Dec. 18, 2010 - Initial release
-// v1.02, Apr. 6, 2011 - Removed 2x2 ordered dither in H2V1 chroma subsampling method load_block_16_8_8(). (The rounding factor was 2, when it should have been 1. Either way, it wasn't helping.)
-// v1.03, Apr. 16, 2011 - Added support for optimized Huffman code tables, optimized dynamic memory allocation down to only 1 alloc.
-//                        Also from Alex Evans: Added RGBA support, linear memory allocator (no longer needed in v1.03).
-// v1.04, May. 19, 2012: Forgot to set m_pFile ptr to NULL in cfile_stream::close(). Thanks to Owen Kaluza for reporting this bug.
-//                       Code tweaks to fix VS2008 static code analysis warnings (all looked harmless).
-//                       Code review revealed method load_block_16_8_8() (used for the non-default H2V1 sampling mode to downsample chroma) somehow didn't get the rounding factor fix from v1.02.
-
-#include "jpge.h"
-
-#include <stdint.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <malloc.h>
-#include "esp_heap_caps.h"
-
-#define JPGE_MAX(a,b) (((a)>(b))?(a):(b))
-#define JPGE_MIN(a,b) (((a)<(b))?(a):(b))
-
-namespace jpge {
-
-    static inline void *jpge_malloc(size_t nSize) {
-        void * b = malloc(nSize);
-        if(b){
-            return b;
-        }
-        return heap_caps_malloc(nSize, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-    }
-    static inline void jpge_free(void *p) { free(p); }
-
-    // Various JPEG enums and tables.
-    enum { M_SOF0 = 0xC0, M_DHT = 0xC4, M_SOI = 0xD8, M_EOI = 0xD9, M_SOS = 0xDA, M_DQT = 0xDB, M_APP0 = 0xE0 };
-    enum { DC_LUM_CODES = 12, AC_LUM_CODES = 256, DC_CHROMA_CODES = 12, AC_CHROMA_CODES = 256, MAX_HUFF_SYMBOLS = 257, MAX_HUFF_CODESIZE = 32 };
-
-    static const uint8 s_zag[64] = { 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63 };
-    static const int16 s_std_lum_quant[64] = { 16,11,12,14,12,10,16,14,13,14,18,17,16,19,24,40,26,24,22,22,24,49,35,37,29,40,58,51,61,60,57,51,56,55,64,72,92,78,64,68,87,69,55,56,80,109,81,87,95,98,103,104,103,62,77,113,121,112,100,120,92,101,103,99 };
-    static const int16 s_std_croma_quant[64] = { 17,18,18,24,21,24,47,26,26,47,99,66,56,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99 };
-    static const uint8 s_dc_lum_bits[17] = { 0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0 };
-    static const uint8 s_dc_lum_val[DC_LUM_CODES] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-    static const uint8 s_ac_lum_bits[17] = { 0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d };
-    static const uint8 s_ac_lum_val[AC_LUM_CODES]  = {
-        0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
-        0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
-        0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
-        0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
-        0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
-        0xf9,0xfa
-    };
-    static const uint8 s_dc_chroma_bits[17] = { 0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };
-    static const uint8 s_dc_chroma_val[DC_CHROMA_CODES]  = { 0,1,2,3,4,5,6,7,8,9,10,11 };
-    static const uint8 s_ac_chroma_bits[17] = { 0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77 };
-    static const uint8 s_ac_chroma_val[AC_CHROMA_CODES] = {
-        0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
-        0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
-        0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
-        0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
-        0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
-        0xf9,0xfa
-    };
-
-    const int YR = 19595, YG = 38470, YB = 7471, CB_R = -11059, CB_G = -21709, CB_B = 32768, CR_R = 32768, CR_G = -27439, CR_B = -5329;
-
-    static int32 m_last_quality = 0;
-    static int32 m_quantization_tables[2][64];
-
-    static bool m_huff_initialized = false;
-    static uint m_huff_codes[4][256];
-    static uint8 m_huff_code_sizes[4][256];
-    static uint8 m_huff_bits[4][17];
-    static uint8 m_huff_val[4][256];
-
-    static inline uint8 clamp(int i) {
-        if (i < 0) {
-            i = 0;
-        } else if (i > 255){
-            i = 255;
-        }
-        return static_cast<uint8>(i);
-    }
-
-    static void RGB_to_YCC(uint8* pDst, const uint8 *pSrc, int num_pixels) {
-        for ( ; num_pixels; pDst += 3, pSrc += 3, num_pixels--) {
-            const int r = pSrc[0], g = pSrc[1], b = pSrc[2];
-            pDst[0] = static_cast<uint8>((r * YR + g * YG + b * YB + 32768) >> 16);
-            pDst[1] = clamp(128 + ((r * CB_R + g * CB_G + b * CB_B + 32768) >> 16));
-            pDst[2] = clamp(128 + ((r * CR_R + g * CR_G + b * CR_B + 32768) >> 16));
-        }
-    }
-
-    static void RGB_to_Y(uint8* pDst, const uint8 *pSrc, int num_pixels) {
-        for ( ; num_pixels; pDst++, pSrc += 3, num_pixels--) {
-            pDst[0] = static_cast<uint8>((pSrc[0] * YR + pSrc[1] * YG + pSrc[2] * YB + 32768) >> 16);
-        }
-    }
-
-    static void Y_to_YCC(uint8* pDst, const uint8* pSrc, int num_pixels) {
-        for( ; num_pixels; pDst += 3, pSrc++, num_pixels--) {
-            pDst[0] = pSrc[0];
-            pDst[1] = 128;
-            pDst[2] = 128;
-        }
-    }
-
-    // Forward DCT - DCT derived from jfdctint.
-    enum { CONST_BITS = 13, ROW_BITS = 2 };
-#define DCT_DESCALE(x, n) (((x) + (((int32)1) << ((n) - 1))) >> (n))
-#define DCT_MUL(var, c) (static_cast<int16>(var) * static_cast<int32>(c))
-#define DCT1D(s0, s1, s2, s3, s4, s5, s6, s7) \
-    int32 t0 = s0 + s7, t7 = s0 - s7, t1 = s1 + s6, t6 = s1 - s6, t2 = s2 + s5, t5 = s2 - s5, t3 = s3 + s4, t4 = s3 - s4; \
-    int32 t10 = t0 + t3, t13 = t0 - t3, t11 = t1 + t2, t12 = t1 - t2; \
-    int32 u1 = DCT_MUL(t12 + t13, 4433); \
-    s2 = u1 + DCT_MUL(t13, 6270); \
-    s6 = u1 + DCT_MUL(t12, -15137); \
-    u1 = t4 + t7; \
-    int32 u2 = t5 + t6, u3 = t4 + t6, u4 = t5 + t7; \
-    int32 z5 = DCT_MUL(u3 + u4, 9633); \
-    t4 = DCT_MUL(t4, 2446); t5 = DCT_MUL(t5, 16819); \
-    t6 = DCT_MUL(t6, 25172); t7 = DCT_MUL(t7, 12299); \
-    u1 = DCT_MUL(u1, -7373); u2 = DCT_MUL(u2, -20995); \
-    u3 = DCT_MUL(u3, -16069); u4 = DCT_MUL(u4, -3196); \
-    u3 += z5; u4 += z5; \
-    s0 = t10 + t11; s1 = t7 + u1 + u4; s3 = t6 + u2 + u3; s4 = t10 - t11; s5 = t5 + u2 + u4; s7 = t4 + u1 + u3;
-
-    static void DCT2D(int32 *p) {
-        int32 c, *q = p;
-        for (c = 7; c >= 0; c--, q += 8) {
-            int32 s0 = q[0], s1 = q[1], s2 = q[2], s3 = q[3], s4 = q[4], s5 = q[5], s6 = q[6], s7 = q[7];
-            DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
-            q[0] = s0 << ROW_BITS; q[1] = DCT_DESCALE(s1, CONST_BITS-ROW_BITS); q[2] = DCT_DESCALE(s2, CONST_BITS-ROW_BITS); q[3] = DCT_DESCALE(s3, CONST_BITS-ROW_BITS);
-            q[4] = s4 << ROW_BITS; q[5] = DCT_DESCALE(s5, CONST_BITS-ROW_BITS); q[6] = DCT_DESCALE(s6, CONST_BITS-ROW_BITS); q[7] = DCT_DESCALE(s7, CONST_BITS-ROW_BITS);
-        }
-        for (q = p, c = 7; c >= 0; c--, q++) {
-            int32 s0 = q[0*8], s1 = q[1*8], s2 = q[2*8], s3 = q[3*8], s4 = q[4*8], s5 = q[5*8], s6 = q[6*8], s7 = q[7*8];
-            DCT1D(s0, s1, s2, s3, s4, s5, s6, s7);
-            q[0*8] = DCT_DESCALE(s0, ROW_BITS+3); q[1*8] = DCT_DESCALE(s1, CONST_BITS+ROW_BITS+3); q[2*8] = DCT_DESCALE(s2, CONST_BITS+ROW_BITS+3); q[3*8] = DCT_DESCALE(s3, CONST_BITS+ROW_BITS+3);
-            q[4*8] = DCT_DESCALE(s4, ROW_BITS+3); q[5*8] = DCT_DESCALE(s5, CONST_BITS+ROW_BITS+3); q[6*8] = DCT_DESCALE(s6, CONST_BITS+ROW_BITS+3); q[7*8] = DCT_DESCALE(s7, CONST_BITS+ROW_BITS+3);
-        }
-    }
-
-    // Compute the actual canonical Huffman codes/code sizes given the JPEG huff bits and val arrays.
-    static void compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits, uint8 *val)
-    {
-        int i, l, last_p, si;
-        static uint8 huff_size[257];
-        static uint huff_code[257];
-        uint code;
-
-        int p = 0;
-        for (l = 1; l <= 16; l++) {
-            for (i = 1; i <= bits[l]; i++) {
-                huff_size[p++] = (char)l;
-            }
-        }
-
-        huff_size[p] = 0;
-        last_p = p; // write sentinel
-
-        code = 0; si = huff_size[0]; p = 0;
-
-        while (huff_size[p]) {
-            while (huff_size[p] == si) {
-                huff_code[p++] = code++;
-            }
-            code <<= 1;
-            si++;
-        }
-
-        memset(codes, 0, sizeof(codes[0])*256);
-        memset(code_sizes, 0, sizeof(code_sizes[0])*256);
-        for (p = 0; p < last_p; p++) {
-            codes[val[p]]      = huff_code[p];
-            code_sizes[val[p]] = huff_size[p];
-        }
-    }
-
-    void jpeg_encoder::flush_output_buffer()
-    {
-        if (m_out_buf_left != JPGE_OUT_BUF_SIZE) {
-            m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_buf(m_out_buf, JPGE_OUT_BUF_SIZE - m_out_buf_left);
-        }
-        m_pOut_buf = m_out_buf;
-        m_out_buf_left = JPGE_OUT_BUF_SIZE;
-    }
-
-    void jpeg_encoder::emit_byte(uint8 i)
-    {
-        *m_pOut_buf++ = i;
-        if (--m_out_buf_left == 0) {
-            flush_output_buffer();
-        }
-    }
-
-    void jpeg_encoder::put_bits(uint bits, uint len)
-    {
-        uint8 c = 0;
-        m_bit_buffer |= ((uint32)bits << (24 - (m_bits_in += len)));
-        while (m_bits_in >= 8) {
-            c = (uint8)((m_bit_buffer >> 16) & 0xFF);
-            emit_byte(c);
-            if (c == 0xFF) {
-                emit_byte(0);
-            }
-            m_bit_buffer <<= 8;
-            m_bits_in -= 8;
-        }
-    }
-
-    void jpeg_encoder::emit_word(uint i)
-    {
-        emit_byte(uint8(i >> 8)); emit_byte(uint8(i & 0xFF));
-    }
-
-    // JPEG marker generation.
-    void jpeg_encoder::emit_marker(int marker)
-    {
-        emit_byte(uint8(0xFF)); emit_byte(uint8(marker));
-    }
-
-    // Emit JFIF marker
-    void jpeg_encoder::emit_jfif_app0()
-    {
-        emit_marker(M_APP0);
-        emit_word(2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1);
-        emit_byte(0x4A); emit_byte(0x46); emit_byte(0x49); emit_byte(0x46); /* Identifier: ASCII "JFIF" */
-        emit_byte(0);
-        emit_byte(1);      /* Major version */
-        emit_byte(1);      /* Minor version */
-        emit_byte(0);      /* Density unit */
-        emit_word(1);
-        emit_word(1);
-        emit_byte(0);      /* No thumbnail image */
-        emit_byte(0);
-    }
-
-    // Emit quantization tables
-    void jpeg_encoder::emit_dqt()
-    {
-        for (int i = 0; i < ((m_num_components == 3) ? 2 : 1); i++)
-        {
-            emit_marker(M_DQT);
-            emit_word(64 + 1 + 2);
-            emit_byte(static_cast<uint8>(i));
-            for (int j = 0; j < 64; j++)
-                emit_byte(static_cast<uint8>(m_quantization_tables[i][j]));
-        }
-    }
-
-    // Emit start of frame marker
-    void jpeg_encoder::emit_sof()
-    {
-        emit_marker(M_SOF0);                           /* baseline */
-        emit_word(3 * m_num_components + 2 + 5 + 1);
-        emit_byte(8);                                  /* precision */
-        emit_word(m_image_y);
-        emit_word(m_image_x);
-        emit_byte(m_num_components);
-        for (int i = 0; i < m_num_components; i++)
-        {
-            emit_byte(static_cast<uint8>(i + 1));                                   /* component ID     */
-            emit_byte((m_comp_h_samp[i] << 4) + m_comp_v_samp[i]);  /* h and v sampling */
-            emit_byte(i > 0);                                   /* quant. table num */
-        }
-    }
-
-    // Emit Huffman table.
-    void jpeg_encoder::emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag)
-    {
-        emit_marker(M_DHT);
-
-        int length = 0;
-        for (int i = 1; i <= 16; i++)
-            length += bits[i];
-
-        emit_word(length + 2 + 1 + 16);
-        emit_byte(static_cast<uint8>(index + (ac_flag << 4)));
-
-        for (int i = 1; i <= 16; i++)
-            emit_byte(bits[i]);
-
-        for (int i = 0; i < length; i++)
-            emit_byte(val[i]);
-    }
-
-    // Emit all Huffman tables.
-    void jpeg_encoder::emit_dhts()
-    {
-        emit_dht(m_huff_bits[0+0], m_huff_val[0+0], 0, false);
-        emit_dht(m_huff_bits[2+0], m_huff_val[2+0], 0, true);
-        if (m_num_components == 3) {
-            emit_dht(m_huff_bits[0+1], m_huff_val[0+1], 1, false);
-            emit_dht(m_huff_bits[2+1], m_huff_val[2+1], 1, true);
-        }
-    }
-
-    // emit start of scan
-    void jpeg_encoder::emit_sos()
-    {
-        emit_marker(M_SOS);
-        emit_word(2 * m_num_components + 2 + 1 + 3);
-        emit_byte(m_num_components);
-        for (int i = 0; i < m_num_components; i++)
-        {
-            emit_byte(static_cast<uint8>(i + 1));
-            if (i == 0)
-                emit_byte((0 << 4) + 0);
-            else
-                emit_byte((1 << 4) + 1);
-        }
-        emit_byte(0);     /* spectral selection */
-        emit_byte(63);
-        emit_byte(0);
-    }
-
-    void jpeg_encoder::load_block_8_8_grey(int x)
-    {
-        uint8 *pSrc;
-        sample_array_t *pDst = m_sample_array;
-        x <<= 3;
-        for (int i = 0; i < 8; i++, pDst += 8)
-        {
-            pSrc = m_mcu_lines[i] + x;
-            pDst[0] = pSrc[0] - 128; pDst[1] = pSrc[1] - 128; pDst[2] = pSrc[2] - 128; pDst[3] = pSrc[3] - 128;
-            pDst[4] = pSrc[4] - 128; pDst[5] = pSrc[5] - 128; pDst[6] = pSrc[6] - 128; pDst[7] = pSrc[7] - 128;
-        }
-    }
-
-    void jpeg_encoder::load_block_8_8(int x, int y, int c)
-    {
-        uint8 *pSrc;
-        sample_array_t *pDst = m_sample_array;
-        x = (x * (8 * 3)) + c;
-        y <<= 3;
-        for (int i = 0; i < 8; i++, pDst += 8)
-        {
-            pSrc = m_mcu_lines[y + i] + x;
-            pDst[0] = pSrc[0 * 3] - 128; pDst[1] = pSrc[1 * 3] - 128; pDst[2] = pSrc[2 * 3] - 128; pDst[3] = pSrc[3 * 3] - 128;
-            pDst[4] = pSrc[4 * 3] - 128; pDst[5] = pSrc[5 * 3] - 128; pDst[6] = pSrc[6 * 3] - 128; pDst[7] = pSrc[7 * 3] - 128;
-        }
-    }
-
-    void jpeg_encoder::load_block_16_8(int x, int c)
-    {
-        uint8 *pSrc1, *pSrc2;
-        sample_array_t *pDst = m_sample_array;
-        x = (x * (16 * 3)) + c;
-        int a = 0, b = 2;
-        for (int i = 0; i < 16; i += 2, pDst += 8)
-        {
-            pSrc1 = m_mcu_lines[i + 0] + x;
-            pSrc2 = m_mcu_lines[i + 1] + x;
-            pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3] + pSrc2[ 0 * 3] + pSrc2[ 1 * 3] + a) >> 2) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3] + pSrc2[ 2 * 3] + pSrc2[ 3 * 3] + b) >> 2) - 128;
-            pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3] + pSrc2[ 4 * 3] + pSrc2[ 5 * 3] + a) >> 2) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3] + pSrc2[ 6 * 3] + pSrc2[ 7 * 3] + b) >> 2) - 128;
-            pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3] + pSrc2[ 8 * 3] + pSrc2[ 9 * 3] + a) >> 2) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3] + pSrc2[10 * 3] + pSrc2[11 * 3] + b) >> 2) - 128;
-            pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3] + pSrc2[12 * 3] + pSrc2[13 * 3] + a) >> 2) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3] + pSrc2[14 * 3] + pSrc2[15 * 3] + b) >> 2) - 128;
-            int temp = a; a = b; b = temp;
-        }
-    }
-
-    void jpeg_encoder::load_block_16_8_8(int x, int c)
-    {
-        uint8 *pSrc1;
-        sample_array_t *pDst = m_sample_array;
-        x = (x * (16 * 3)) + c;
-        for (int i = 0; i < 8; i++, pDst += 8)
-        {
-            pSrc1 = m_mcu_lines[i + 0] + x;
-            pDst[0] = ((pSrc1[ 0 * 3] + pSrc1[ 1 * 3]) >> 1) - 128; pDst[1] = ((pSrc1[ 2 * 3] + pSrc1[ 3 * 3]) >> 1) - 128;
-            pDst[2] = ((pSrc1[ 4 * 3] + pSrc1[ 5 * 3]) >> 1) - 128; pDst[3] = ((pSrc1[ 6 * 3] + pSrc1[ 7 * 3]) >> 1) - 128;
-            pDst[4] = ((pSrc1[ 8 * 3] + pSrc1[ 9 * 3]) >> 1) - 128; pDst[5] = ((pSrc1[10 * 3] + pSrc1[11 * 3]) >> 1) - 128;
-            pDst[6] = ((pSrc1[12 * 3] + pSrc1[13 * 3]) >> 1) - 128; pDst[7] = ((pSrc1[14 * 3] + pSrc1[15 * 3]) >> 1) - 128;
-        }
-    }
-
-    void jpeg_encoder::load_quantized_coefficients(int component_num)
-    {
-        int32 *q = m_quantization_tables[component_num > 0];
-        int16 *pDst = m_coefficient_array;
-        for (int i = 0; i < 64; i++)
-        {
-            sample_array_t j = m_sample_array[s_zag[i]];
-            if (j < 0)
-            {
-                if ((j = -j + (*q >> 1)) < *q)
-                    *pDst++ = 0;
-                else
-                    *pDst++ = static_cast<int16>(-(j / *q));
-            }
-            else
-            {
-                if ((j = j + (*q >> 1)) < *q)
-                    *pDst++ = 0;
-                else
-                    *pDst++ = static_cast<int16>((j / *q));
-            }
-            q++;
-        }
-    }
-
-    void jpeg_encoder::code_coefficients_pass_two(int component_num)
-    {
-        int i, j, run_len, nbits, temp1, temp2;
-        int16 *pSrc = m_coefficient_array;
-        uint *codes[2];
-        uint8 *code_sizes[2];
-
-        if (component_num == 0)
-        {
-            codes[0] = m_huff_codes[0 + 0]; codes[1] = m_huff_codes[2 + 0];
-            code_sizes[0] = m_huff_code_sizes[0 + 0]; code_sizes[1] = m_huff_code_sizes[2 + 0];
-        }
-        else
-        {
-            codes[0] = m_huff_codes[0 + 1]; codes[1] = m_huff_codes[2 + 1];
-            code_sizes[0] = m_huff_code_sizes[0 + 1]; code_sizes[1] = m_huff_code_sizes[2 + 1];
-        }
-
-        temp1 = temp2 = pSrc[0] - m_last_dc_val[component_num];
-        m_last_dc_val[component_num] = pSrc[0];
-
-        if (temp1 < 0)
-        {
-            temp1 = -temp1; temp2--;
-        }
-
-        nbits = 0;
-        while (temp1)
-        {
-            nbits++; temp1 >>= 1;
-        }
-
-        put_bits(codes[0][nbits], code_sizes[0][nbits]);
-        if (nbits) put_bits(temp2 & ((1 << nbits) - 1), nbits);
-
-        for (run_len = 0, i = 1; i < 64; i++)
-        {
-            if ((temp1 = m_coefficient_array[i]) == 0)
-                run_len++;
-            else
-            {
-                while (run_len >= 16)
-                {
-                    put_bits(codes[1][0xF0], code_sizes[1][0xF0]);
-                    run_len -= 16;
-                }
-                if ((temp2 = temp1) < 0)
-                {
-                    temp1 = -temp1;
-                    temp2--;
-                }
-                nbits = 1;
-                while (temp1 >>= 1)
-                    nbits++;
-                j = (run_len << 4) + nbits;
-                put_bits(codes[1][j], code_sizes[1][j]);
-                put_bits(temp2 & ((1 << nbits) - 1), nbits);
-                run_len = 0;
-            }
-        }
-        if (run_len)
-            put_bits(codes[1][0], code_sizes[1][0]);
-    }
-
-    void jpeg_encoder::code_block(int component_num)
-    {
-        DCT2D(m_sample_array);
-        load_quantized_coefficients(component_num);
-        code_coefficients_pass_two(component_num);
-    }
-
-    void jpeg_encoder::process_mcu_row()
-    {
-        if (m_num_components == 1)
-        {
-            for (int i = 0; i < m_mcus_per_row; i++)
-            {
-                load_block_8_8_grey(i); code_block(0);
-            }
-        }
-        else if ((m_comp_h_samp[0] == 1) && (m_comp_v_samp[0] == 1))
-        {
-            for (int i = 0; i < m_mcus_per_row; i++)
-            {
-                load_block_8_8(i, 0, 0); code_block(0); load_block_8_8(i, 0, 1); code_block(1); load_block_8_8(i, 0, 2); code_block(2);
-            }
-        }
-        else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 1))
-        {
-            for (int i = 0; i < m_mcus_per_row; i++)
-            {
-                load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
-                load_block_16_8_8(i, 1); code_block(1); load_block_16_8_8(i, 2); code_block(2);
-            }
-        }
-        else if ((m_comp_h_samp[0] == 2) && (m_comp_v_samp[0] == 2))
-        {
-            for (int i = 0; i < m_mcus_per_row; i++)
-            {
-                load_block_8_8(i * 2 + 0, 0, 0); code_block(0); load_block_8_8(i * 2 + 1, 0, 0); code_block(0);
-                load_block_8_8(i * 2 + 0, 1, 0); code_block(0); load_block_8_8(i * 2 + 1, 1, 0); code_block(0);
-                load_block_16_8(i, 1); code_block(1); load_block_16_8(i, 2); code_block(2);
-            }
-        }
-    }
-
-    void jpeg_encoder::load_mcu(const void *pSrc)
-    {
-        const uint8* Psrc = reinterpret_cast<const uint8*>(pSrc);
-
-        uint8* pDst = m_mcu_lines[m_mcu_y_ofs]; // OK to write up to m_image_bpl_xlt bytes to pDst
-
-        if (m_num_components == 1) {
-            if (m_image_bpp == 3)
-                RGB_to_Y(pDst, Psrc, m_image_x);
-            else
-                memcpy(pDst, Psrc, m_image_x);
-        } else {
-            if (m_image_bpp == 3)
-                RGB_to_YCC(pDst, Psrc, m_image_x);
-            else
-                Y_to_YCC(pDst, Psrc, m_image_x);
-        }
-
-        // Possibly duplicate pixels at end of scanline if not a multiple of 8 or 16
-        if (m_num_components == 1)
-            memset(m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt, pDst[m_image_bpl_xlt - 1], m_image_x_mcu - m_image_x);
-        else
-        {
-            const uint8 y = pDst[m_image_bpl_xlt - 3 + 0], cb = pDst[m_image_bpl_xlt - 3 + 1], cr = pDst[m_image_bpl_xlt - 3 + 2];
-            uint8 *q = m_mcu_lines[m_mcu_y_ofs] + m_image_bpl_xlt;
-            for (int i = m_image_x; i < m_image_x_mcu; i++)
-            {
-                *q++ = y; *q++ = cb; *q++ = cr;
-            }
-        }
-
-        if (++m_mcu_y_ofs == m_mcu_y)
-        {
-            process_mcu_row();
-            m_mcu_y_ofs = 0;
-        }
-    }
-
-    // Quantization table generation.
-    void jpeg_encoder::compute_quant_table(int32 *pDst, const int16 *pSrc)
-    {
-        int32 q;
-        if (m_params.m_quality < 50)
-            q = 5000 / m_params.m_quality;
-        else
-            q = 200 - m_params.m_quality * 2;
-        for (int i = 0; i < 64; i++)
-        {
-            int32 j = *pSrc++; j = (j * q + 50L) / 100L;
-            *pDst++ = JPGE_MIN(JPGE_MAX(j, 1), 255);
-        }
-    }
-
-    // Higher-level methods.
-    bool jpeg_encoder::jpg_open(int p_x_res, int p_y_res, int src_channels)
-    {
-        m_num_components = 3;
-        switch (m_params.m_subsampling)
-        {
-            case Y_ONLY:
-            {
-                m_num_components = 1;
-                m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
-                m_mcu_x          = 8; m_mcu_y          = 8;
-                break;
-            }
-            case H1V1:
-            {
-                m_comp_h_samp[0] = 1; m_comp_v_samp[0] = 1;
-                m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-                m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-                m_mcu_x          = 8; m_mcu_y          = 8;
-                break;
-            }
-            case H2V1:
-            {
-                m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 1;
-                m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-                m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-                m_mcu_x          = 16; m_mcu_y         = 8;
-                break;
-            }
-            case H2V2:
-            {
-                m_comp_h_samp[0] = 2; m_comp_v_samp[0] = 2;
-                m_comp_h_samp[1] = 1; m_comp_v_samp[1] = 1;
-                m_comp_h_samp[2] = 1; m_comp_v_samp[2] = 1;
-                m_mcu_x          = 16; m_mcu_y         = 16;
-            }
-        }
-
-        m_image_x        = p_x_res; m_image_y = p_y_res;
-        m_image_bpp      = src_channels;
-        m_image_bpl      = m_image_x * src_channels;
-        m_image_x_mcu    = (m_image_x + m_mcu_x - 1) & (~(m_mcu_x - 1));
-        m_image_y_mcu    = (m_image_y + m_mcu_y - 1) & (~(m_mcu_y - 1));
-        m_image_bpl_xlt  = m_image_x * m_num_components;
-        m_image_bpl_mcu  = m_image_x_mcu * m_num_components;
-        m_mcus_per_row   = m_image_x_mcu / m_mcu_x;
-
-        if ((m_mcu_lines[0] = static_cast<uint8*>(jpge_malloc(m_image_bpl_mcu * m_mcu_y))) == NULL) {
-            return false;
-        }
-        for (int i = 1; i < m_mcu_y; i++)
-            m_mcu_lines[i] = m_mcu_lines[i-1] + m_image_bpl_mcu;
-
-        if(m_last_quality != m_params.m_quality){
-            m_last_quality = m_params.m_quality;
-            compute_quant_table(m_quantization_tables[0], s_std_lum_quant);
-            compute_quant_table(m_quantization_tables[1], s_std_croma_quant);
-        }
-
-        if(!m_huff_initialized){
-            m_huff_initialized = true;
-
-            memcpy(m_huff_bits[0+0], s_dc_lum_bits, 17);    memcpy(m_huff_val[0+0], s_dc_lum_val, DC_LUM_CODES);
-            memcpy(m_huff_bits[2+0], s_ac_lum_bits, 17);    memcpy(m_huff_val[2+0], s_ac_lum_val, AC_LUM_CODES);
-            memcpy(m_huff_bits[0+1], s_dc_chroma_bits, 17); memcpy(m_huff_val[0+1], s_dc_chroma_val, DC_CHROMA_CODES);
-            memcpy(m_huff_bits[2+1], s_ac_chroma_bits, 17); memcpy(m_huff_val[2+1], s_ac_chroma_val, AC_CHROMA_CODES);
-
-            compute_huffman_table(&m_huff_codes[0+0][0], &m_huff_code_sizes[0+0][0], m_huff_bits[0+0], m_huff_val[0+0]);
-            compute_huffman_table(&m_huff_codes[2+0][0], &m_huff_code_sizes[2+0][0], m_huff_bits[2+0], m_huff_val[2+0]);
-            compute_huffman_table(&m_huff_codes[0+1][0], &m_huff_code_sizes[0+1][0], m_huff_bits[0+1], m_huff_val[0+1]);
-            compute_huffman_table(&m_huff_codes[2+1][0], &m_huff_code_sizes[2+1][0], m_huff_bits[2+1], m_huff_val[2+1]);
-        }
-
-        m_out_buf_left = JPGE_OUT_BUF_SIZE;
-        m_pOut_buf = m_out_buf;
-        m_bit_buffer = 0;
-        m_bits_in = 0;
-        m_mcu_y_ofs = 0;
-        m_pass_num = 2;
-        memset(m_last_dc_val, 0, 3 * sizeof(m_last_dc_val[0]));
-
-        // Emit all markers at beginning of image file.
-        emit_marker(M_SOI);
-        emit_jfif_app0();
-        emit_dqt();
-        emit_sof();
-        emit_dhts();
-        emit_sos();
-
-        return m_all_stream_writes_succeeded;
-    }
-
-    bool jpeg_encoder::process_end_of_image()
-    {
-        if (m_mcu_y_ofs) {
-            if (m_mcu_y_ofs < 16) { // check here just to shut up static analysis
-                for (int i = m_mcu_y_ofs; i < m_mcu_y; i++) {
-                    memcpy(m_mcu_lines[i], m_mcu_lines[m_mcu_y_ofs - 1], m_image_bpl_mcu);
-                }
-            }
-            process_mcu_row();
-        }
-
-        put_bits(0x7F, 7);
-        emit_marker(M_EOI);
-        flush_output_buffer();
-        m_all_stream_writes_succeeded = m_all_stream_writes_succeeded && m_pStream->put_buf(NULL, 0);
-        m_pass_num++; // purposely bump up m_pass_num, for debugging
-        return true;
-    }
-
-    void jpeg_encoder::clear()
-    {
-        m_mcu_lines[0] = NULL;
-        m_pass_num = 0;
-        m_all_stream_writes_succeeded = true;
-    }
-
-    jpeg_encoder::jpeg_encoder()
-    {
-        clear();
-    }
-
-    jpeg_encoder::~jpeg_encoder()
-    {
-        deinit();
-    }
-
-    bool jpeg_encoder::init(output_stream *pStream, int width, int height, int src_channels, const params &comp_params)
-    {
-        deinit();
-        if (((!pStream) || (width < 1) || (height < 1)) || ((src_channels != 1) && (src_channels != 3) && (src_channels != 4)) || (!comp_params.check())) return false;
-        m_pStream = pStream;
-        m_params = comp_params;
-        return jpg_open(width, height, src_channels);
-    }
-
-    void jpeg_encoder::deinit()
-    {
-        jpge_free(m_mcu_lines[0]);
-        clear();
-    }
-
-    bool jpeg_encoder::process_scanline(const void* pScanline)
-    {
-        if ((m_pass_num < 1) || (m_pass_num > 2)) {
-            return false;
-        }
-        if (m_all_stream_writes_succeeded) {
-            if (!pScanline) {
-                if (!process_end_of_image()) {
-                    return false;
-                }
-            } else {
-                load_mcu(pScanline);
-            }
-        }
-        return m_all_stream_writes_succeeded;
-    }
-
-} // namespace jpge
--- a/code/components/esp32-camera-master/conversions/private_include/jpge.h
+++ b/code/components/esp32-camera-master/conversions/private_include/jpge.h
@@ -1,142 +0,0 @@
-// jpge.h - C++ class for JPEG compression.
-// Public domain, Rich Geldreich <richgel99@gmail.com>
-// Alex Evans: Added RGBA support, linear memory allocator.
-#ifndef JPEG_ENCODER_H
-#define JPEG_ENCODER_H
-
-namespace jpge
-{
-    typedef unsigned char  uint8;
-    typedef signed short   int16;
-    typedef signed int     int32;
-    typedef unsigned short uint16;
-    typedef unsigned int   uint32;
-    typedef unsigned int   uint;
-
-    // JPEG chroma subsampling factors. Y_ONLY (grayscale images) and H2V2 (color images) are the most common.
-    enum subsampling_t { Y_ONLY = 0, H1V1 = 1, H2V1 = 2, H2V2 = 3 };
-
-    // JPEG compression parameters structure.
-    struct params {
-            inline params() : m_quality(85), m_subsampling(H2V2) { }
-
-            inline bool check() const {
-                if ((m_quality < 1) || (m_quality > 100)) {
-                    return false;
-                }
-                if ((uint)m_subsampling > (uint)H2V2) {
-                    return false;
-                }
-                return true;
-            }
-
-            // Quality: 1-100, higher is better. Typical values are around 50-95.
-            int m_quality;
-
-            // m_subsampling:
-            // 0 = Y (grayscale) only
-            // 1 = H1V1 subsampling (YCbCr 1x1x1, 3 blocks per MCU)
-            // 2 = H2V1 subsampling (YCbCr 2x1x1, 4 blocks per MCU)
-            // 3 = H2V2 subsampling (YCbCr 4x1x1, 6 blocks per MCU-- very common)
-            subsampling_t m_subsampling;
-    };
-    
-    // Output stream abstract class - used by the jpeg_encoder class to write to the output stream.
-    // put_buf() is generally called with len==JPGE_OUT_BUF_SIZE bytes, but for headers it'll be called with smaller amounts.
-    class output_stream {
-        public:
-            virtual ~output_stream() { };
-            virtual bool put_buf(const void* Pbuf, int len) = 0;
-            virtual uint get_size() const = 0;
-    };
-    
-    // Lower level jpeg_encoder class - useful if more control is needed than the above helper functions.
-    class jpeg_encoder {
-        public:
-            jpeg_encoder();
-            ~jpeg_encoder();
-
-            // Initializes the compressor.
-            // pStream: The stream object to use for writing compressed data.
-            // params - Compression parameters structure, defined above.
-            // width, height  - Image dimensions.
-            // channels - May be 1, or 3. 1 indicates grayscale, 3 indicates RGB source data.
-            // Returns false on out of memory or if a stream write fails.
-            bool init(output_stream *pStream, int width, int height, int src_channels, const params &comp_params = params());
-
-            // Call this method with each source scanline.
-            // width * src_channels bytes per scanline is expected (RGB or Y format).
-            // You must call with NULL after all scanlines are processed to finish compression.
-            // Returns false on out of memory or if a stream write fails.
-            bool process_scanline(const void* pScanline);
-
-            // Deinitializes the compressor, freeing any allocated memory. May be called at any time.
-            void deinit();
-
-        private:
-            jpeg_encoder(const jpeg_encoder &);
-            jpeg_encoder &operator =(const jpeg_encoder &);
-
-            typedef int32 sample_array_t;
-            enum { JPGE_OUT_BUF_SIZE = 512 };
-
-            output_stream *m_pStream;
-            params m_params;
-            uint8 m_num_components;
-            uint8 m_comp_h_samp[3], m_comp_v_samp[3];
-            int m_image_x, m_image_y, m_image_bpp, m_image_bpl;
-            int m_image_x_mcu, m_image_y_mcu;
-            int m_image_bpl_xlt, m_image_bpl_mcu;
-            int m_mcus_per_row;
-            int m_mcu_x, m_mcu_y;
-            uint8 *m_mcu_lines[16];
-            uint8 m_mcu_y_ofs;
-            sample_array_t m_sample_array[64];
-            int16 m_coefficient_array[64];
-
-            int m_last_dc_val[3];
-            uint8 m_out_buf[JPGE_OUT_BUF_SIZE];
-            uint8 *m_pOut_buf;
-            uint m_out_buf_left;
-            uint32 m_bit_buffer;
-            uint m_bits_in;
-            uint8 m_pass_num;
-            bool m_all_stream_writes_succeeded;
-
-            bool jpg_open(int p_x_res, int p_y_res, int src_channels);
-
-            void flush_output_buffer();
-            void put_bits(uint bits, uint len);
-
-            void emit_byte(uint8 i);
-            void emit_word(uint i);
-            void emit_marker(int marker);
-
-            void emit_jfif_app0();
-            void emit_dqt();
-            void emit_sof();
-            void emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag);
-            void emit_dhts();
-            void emit_sos();
-
-            void compute_quant_table(int32 *dst, const int16 *src);
-            void load_quantized_coefficients(int component_num);
-
-            void load_block_8_8_grey(int x);
-            void load_block_8_8(int x, int y, int c);
-            void load_block_16_8(int x, int c);
-            void load_block_16_8_8(int x, int c);
-
-            void code_coefficients_pass_two(int component_num);
-            void code_block(int component_num);
-
-            void process_mcu_row();
-            bool process_end_of_image();
-            void load_mcu(const void* src);
-            void clear();
-            void init();
-    };
-    
-} // namespace jpge
-
-#endif // JPEG_ENCODER
--- a/code/components/esp32-camera-master/conversions/private_include/yuv.h
+++ b/code/components/esp32-camera-master/conversions/private_include/yuv.h
@@ -1,29 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _CONVERSIONS_YUV_H_
-#define _CONVERSIONS_YUV_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-void yuv2rgb(uint8_t y, uint8_t u, uint8_t v, uint8_t *r, uint8_t *g, uint8_t *b);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONVERSIONS_YUV_H_ */
--- a/code/components/esp32-camera-master/conversions/to_bmp.c
+++ b/code/components/esp32-camera-master/conversions/to_bmp.c
@@ -1,326 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <stddef.h>
-#include <string.h>
-#include "img_converters.h"
-#include "soc/efuse_reg.h"
-#include "esp_heap_caps.h"
-#include "yuv.h"
-#include "sdkconfig.h"
-#include "esp_jpg_decode.h"
-
-#include "esp_system.h"
-#if ESP_IDF_VERSION_MAJOR >= 4 // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/spiram.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "esp_spiram.h"
-#endif
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#define TAG ""
-#else
-#include "esp_log.h"
-static const char* TAG = "to_bmp";
-#endif
-
-static const int BMP_HEADER_LEN = 54;
-
-typedef struct {
-    uint32_t filesize;
-    uint32_t reserved;
-    uint32_t fileoffset_to_pixelarray;
-    uint32_t dibheadersize;
-    int32_t width;
-    int32_t height;
-    uint16_t planes;
-    uint16_t bitsperpixel;
-    uint32_t compression;
-    uint32_t imagesize;
-    uint32_t ypixelpermeter;
-    uint32_t xpixelpermeter;
-    uint32_t numcolorspallette;
-    uint32_t mostimpcolor;
-} bmp_header_t;
-
-typedef struct {
-        uint16_t width;
-        uint16_t height;
-        uint16_t data_offset;
-        const uint8_t *input;
-        uint8_t *output;
-} rgb_jpg_decoder;
-
-static void *_malloc(size_t size)
-{
-    return heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-}
-
-//output buffer and image width
-static bool _rgb_write(void * arg, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t *data)
-{
-    rgb_jpg_decoder * jpeg = (rgb_jpg_decoder *)arg;
-    if(!data){
-        if(x == 0 && y == 0){
-            //write start
-            jpeg->width = w;
-            jpeg->height = h;
-            //if output is null, this is BMP
-            if(!jpeg->output){
-                jpeg->output = (uint8_t *)_malloc((w*h*3)+jpeg->data_offset);
-                if(!jpeg->output){
-                    return false;
-                }
-            }
-        } else {
-            //write end
-        }
-        return true;
-    }
-
-    size_t jw = jpeg->width*3;
-    size_t t = y * jw;
-    size_t b = t + (h * jw);
-    size_t l = x * 3;
-    uint8_t *out = jpeg->output+jpeg->data_offset;
-    uint8_t *o = out;
-    size_t iy, ix;
-
-    w = w * 3;
-
-    for(iy=t; iy<b; iy+=jw) {
-        o = out+iy+l;
-        for(ix=0; ix<w; ix+= 3) {
-            o[ix] = data[ix+2];
-            o[ix+1] = data[ix+1];
-            o[ix+2] = data[ix];
-        }
-        data+=w;
-    }
-    return true;
-}
-
-//input buffer
-static uint32_t _jpg_read(void * arg, size_t index, uint8_t *buf, size_t len)
-{
-    rgb_jpg_decoder * jpeg = (rgb_jpg_decoder *)arg;
-    if(buf) {
-        memcpy(buf, jpeg->input + index, len);
-    }
-    return len;
-}
-
-static bool jpg2rgb888(const uint8_t *src, size_t src_len, uint8_t * out, jpg_scale_t scale)
-{
-    rgb_jpg_decoder jpeg;
-    jpeg.width = 0;
-    jpeg.height = 0;
-    jpeg.input = src;
-    jpeg.output = out;
-    jpeg.data_offset = 0;
-
-    if(esp_jpg_decode(src_len, scale, _jpg_read, _rgb_write, (void*)&jpeg) != ESP_OK){
-        return false;
-    }
-    return true;
-}
-
-bool jpg2bmp(const uint8_t *src, size_t src_len, uint8_t ** out, size_t * out_len)
-{
-
-    rgb_jpg_decoder jpeg;
-    jpeg.width = 0;
-    jpeg.height = 0;
-    jpeg.input = src;
-    jpeg.output = NULL;
-    jpeg.data_offset = BMP_HEADER_LEN;
-
-    if(esp_jpg_decode(src_len, JPG_SCALE_NONE, _jpg_read, _rgb_write, (void*)&jpeg) != ESP_OK){
-        return false;
-    }
-
-    size_t output_size = jpeg.width*jpeg.height*3;
-
-    jpeg.output[0] = 'B';
-    jpeg.output[1] = 'M';
-    bmp_header_t * bitmap  = (bmp_header_t*)&jpeg.output[2];
-    bitmap->reserved = 0;
-    bitmap->filesize = output_size+BMP_HEADER_LEN;
-    bitmap->fileoffset_to_pixelarray = BMP_HEADER_LEN;
-    bitmap->dibheadersize = 40;
-    bitmap->width = jpeg.width;
-    bitmap->height = -jpeg.height;//set negative for top to bottom
-    bitmap->planes = 1;
-    bitmap->bitsperpixel = 24;
-    bitmap->compression = 0;
-    bitmap->imagesize = output_size;
-    bitmap->ypixelpermeter = 0x0B13 ; //2835 , 72 DPI
-    bitmap->xpixelpermeter = 0x0B13 ; //2835 , 72 DPI
-    bitmap->numcolorspallette = 0;
-    bitmap->mostimpcolor = 0;
-
-    *out = jpeg.output;
-    *out_len = output_size+BMP_HEADER_LEN;
-
-    return true;
-}
-
-bool fmt2rgb888(const uint8_t *src_buf, size_t src_len, pixformat_t format, uint8_t * rgb_buf)
-{
-    int pix_count = 0;
-    if(format == PIXFORMAT_JPEG) {
-        return jpg2rgb888(src_buf, src_len, rgb_buf, JPG_SCALE_NONE);
-    } else if(format == PIXFORMAT_RGB888) {
-        memcpy(rgb_buf, src_buf, src_len);
-    } else if(format == PIXFORMAT_RGB565) {
-        int i;
-        uint8_t hb, lb;
-        pix_count = src_len / 2;
-        for(i=0; i<pix_count; i++) {
-            hb = *src_buf++;
-            lb = *src_buf++;
-            *rgb_buf++ = (lb & 0x1F) << 3;
-            *rgb_buf++ = (hb & 0x07) << 5 | (lb & 0xE0) >> 3;
-            *rgb_buf++ = hb & 0xF8;
-        }
-    } else if(format == PIXFORMAT_GRAYSCALE) {
-        int i;
-        uint8_t b;
-        pix_count = src_len;
-        for(i=0; i<pix_count; i++) {
-            b = *src_buf++;
-            *rgb_buf++ = b;
-            *rgb_buf++ = b;
-            *rgb_buf++ = b;
-        }
-    } else if(format == PIXFORMAT_YUV422) {
-        pix_count = src_len / 2;
-        int i, maxi = pix_count / 2;
-        uint8_t y0, y1, u, v;
-        uint8_t r, g, b;
-        for(i=0; i<maxi; i++) {
-            y0 = *src_buf++;
-            u = *src_buf++;
-            y1 = *src_buf++;
-            v = *src_buf++;
-
-            yuv2rgb(y0, u, v, &r, &g, &b);
-            *rgb_buf++ = b;
-            *rgb_buf++ = g;
-            *rgb_buf++ = r;
-
-            yuv2rgb(y1, u, v, &r, &g, &b);
-            *rgb_buf++ = b;
-            *rgb_buf++ = g;
-            *rgb_buf++ = r;
-        }
-    }
-    return true;
-}
-
-bool fmt2bmp(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t ** out, size_t * out_len)
-{
-    if(format == PIXFORMAT_JPEG) {
-        return jpg2bmp(src, src_len, out, out_len);
-    }
-
-    *out = NULL;
-    *out_len = 0;
-
-    int pix_count = width*height;
-    size_t out_size = (pix_count * 3) + BMP_HEADER_LEN;
-    uint8_t * out_buf = (uint8_t *)_malloc(out_size);
-    if(!out_buf) {
-        ESP_LOGE(TAG, "_malloc failed! %u", out_size);
-        return false;
-    }
-
-    out_buf[0] = 'B';
-    out_buf[1] = 'M';
-    bmp_header_t * bitmap  = (bmp_header_t*)&out_buf[2];
-    bitmap->reserved = 0;
-    bitmap->filesize = out_size;
-    bitmap->fileoffset_to_pixelarray = BMP_HEADER_LEN;
-    bitmap->dibheadersize = 40;
-    bitmap->width = width;
-    bitmap->height = -height;//set negative for top to bottom
-    bitmap->planes = 1;
-    bitmap->bitsperpixel = 24;
-    bitmap->compression = 0;
-    bitmap->imagesize = pix_count * 3;
-    bitmap->ypixelpermeter = 0x0B13 ; //2835 , 72 DPI
-    bitmap->xpixelpermeter = 0x0B13 ; //2835 , 72 DPI
-    bitmap->numcolorspallette = 0;
-    bitmap->mostimpcolor = 0;
-
-    uint8_t * rgb_buf = out_buf + BMP_HEADER_LEN;
-    uint8_t * src_buf = src;
-
-
-    //convert data to RGB888
-    if(format == PIXFORMAT_RGB888) {
-        memcpy(rgb_buf, src_buf, pix_count*3);
-    } else if(format == PIXFORMAT_RGB565) {
-        int i;
-        uint8_t hb, lb;
-        for(i=0; i<pix_count; i++) {
-            hb = *src_buf++;
-            lb = *src_buf++;
-            *rgb_buf++ = (lb & 0x1F) << 3;
-            *rgb_buf++ = (hb & 0x07) << 5 | (lb & 0xE0) >> 3;
-            *rgb_buf++ = hb & 0xF8;
-        }
-    } else if(format == PIXFORMAT_GRAYSCALE) {
-        int i;
-        uint8_t b;
-        for(i=0; i<pix_count; i++) {
-            b = *src_buf++;
-            *rgb_buf++ = b;
-            *rgb_buf++ = b;
-            *rgb_buf++ = b;
-        }
-    } else if(format == PIXFORMAT_YUV422) {
-        int i, maxi = pix_count / 2;
-        uint8_t y0, y1, u, v;
-        uint8_t r, g, b;
-        for(i=0; i<maxi; i++) {
-            y0 = *src_buf++;
-            u = *src_buf++;
-            y1 = *src_buf++;
-            v = *src_buf++;
-
-            yuv2rgb(y0, u, v, &r, &g, &b);
-            *rgb_buf++ = b;
-            *rgb_buf++ = g;
-            *rgb_buf++ = r;
-
-            yuv2rgb(y1, u, v, &r, &g, &b);
-            *rgb_buf++ = b;
-            *rgb_buf++ = g;
-            *rgb_buf++ = r;
-        }
-    }
-    *out = out_buf;
-    *out_len = out_size;
-    return true; 
-}
-
-bool frame2bmp(camera_fb_t * fb, uint8_t ** out, size_t * out_len)
-{
-    return fmt2bmp(fb->buf, fb->len, fb->width, fb->height, fb->format, out, out_len);
-}
--- a/code/components/esp32-camera-master/conversions/to_jpg.cpp
+++ b/code/components/esp32-camera-master/conversions/to_jpg.cpp
@@ -1,241 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <stddef.h>
-#include <string.h>
-#include "esp_attr.h"
-#include "soc/efuse_reg.h"
-#include "esp_heap_caps.h"
-#include "esp_camera.h"
-#include "img_converters.h"
-#include "jpge.h"
-#include "yuv.h"
-
-#include "esp_system.h"
-#if ESP_IDF_VERSION_MAJOR >= 4 // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/spiram.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "esp_spiram.h"
-#endif
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#define TAG ""
-#else
-#include "esp_log.h"
-static const char* TAG = "to_jpg";
-#endif
-
-static void *_malloc(size_t size)
-{
-    void * res = malloc(size);
-    if(res) {
-        return res;
-    }
-    return heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-}
-
-static IRAM_ATTR void convert_line_format(uint8_t * src, pixformat_t format, uint8_t * dst, size_t width, size_t in_channels, size_t line)
-{
-    int i=0, o=0, l=0;
-    if(format == PIXFORMAT_GRAYSCALE) {
-        memcpy(dst, src + line * width, width);
-    } else if(format == PIXFORMAT_RGB888) {
-        l = width * 3;
-        src += l * line;
-        for(i=0; i<l; i+=3) {
-            dst[o++] = src[i+2];
-            dst[o++] = src[i+1];
-            dst[o++] = src[i];
-        }
-    } else if(format == PIXFORMAT_RGB565) {
-        l = width * 2;
-        src += l * line;
-        for(i=0; i<l; i+=2) {
-            dst[o++] = src[i] & 0xF8;
-            dst[o++] = (src[i] & 0x07) << 5 | (src[i+1] & 0xE0) >> 3;
-            dst[o++] = (src[i+1] & 0x1F) << 3;
-        }
-    } else if(format == PIXFORMAT_YUV422) {
-        uint8_t y0, y1, u, v;
-        uint8_t r, g, b;
-        l = width * 2;
-        src += l * line;
-        for(i=0; i<l; i+=4) {
-            y0 = src[i];
-            u = src[i+1];
-            y1 = src[i+2];
-            v = src[i+3];
-
-            yuv2rgb(y0, u, v, &r, &g, &b);
-            dst[o++] = r;
-            dst[o++] = g;
-            dst[o++] = b;
-
-            yuv2rgb(y1, u, v, &r, &g, &b);
-            dst[o++] = r;
-            dst[o++] = g;
-            dst[o++] = b;
-        }
-    }
-}
-
-bool convert_image(uint8_t *src, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, jpge::output_stream *dst_stream)
-{
-    int num_channels = 3;
-    jpge::subsampling_t subsampling = jpge::H2V2;
-
-    if(format == PIXFORMAT_GRAYSCALE) {
-        num_channels = 1;
-        subsampling = jpge::Y_ONLY;
-    }
-
-    if(!quality) {
-        quality = 1;
-    } else if(quality > 100) {
-        quality = 100;
-    }
-
-    jpge::params comp_params = jpge::params();
-    comp_params.m_subsampling = subsampling;
-    comp_params.m_quality = quality;
-
-    jpge::jpeg_encoder dst_image;
-
-    if (!dst_image.init(dst_stream, width, height, num_channels, comp_params)) {
-        ESP_LOGE(TAG, "JPG encoder init failed");
-        return false;
-    }
-
-    uint8_t* line = (uint8_t*)_malloc(width * num_channels);
-    if(!line) {
-        ESP_LOGE(TAG, "Scan line malloc failed");
-        return false;
-    }
-
-    for (int i = 0; i < height; i++) {
-        convert_line_format(src, format, line, width, num_channels, i);
-        if (!dst_image.process_scanline(line)) {
-            ESP_LOGE(TAG, "JPG process line %u failed", i);
-            free(line);
-            return false;
-        }
-    }
-    free(line);
-
-    if (!dst_image.process_scanline(NULL)) {
-        ESP_LOGE(TAG, "JPG image finish failed");
-        return false;
-    }
-    dst_image.deinit();
-    return true;
-}
-
-class callback_stream : public jpge::output_stream {
-protected:
-    jpg_out_cb ocb;
-    void * oarg;
-    size_t index;
-
-public:
-    callback_stream(jpg_out_cb cb, void * arg) : ocb(cb), oarg(arg), index(0) { }
-    virtual ~callback_stream() { }
-    virtual bool put_buf(const void* data, int len)
-    {
-        index += ocb(oarg, index, data, len);
-        return true;
-    }
-    virtual size_t get_size() const
-    {
-        return index;
-    }
-};
-
-bool fmt2jpg_cb(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, jpg_out_cb cb, void * arg)
-{
-    callback_stream dst_stream(cb, arg);
-    return convert_image(src, width, height, format, quality, &dst_stream);
-}
-
-bool frame2jpg_cb(camera_fb_t * fb, uint8_t quality, jpg_out_cb cb, void * arg)
-{
-    return fmt2jpg_cb(fb->buf, fb->len, fb->width, fb->height, fb->format, quality, cb, arg);
-}
-
-
-
-class memory_stream : public jpge::output_stream {
-protected:
-    uint8_t *out_buf;
-    size_t max_len, index;
-
-public:
-    memory_stream(void *pBuf, uint buf_size) : out_buf(static_cast<uint8_t*>(pBuf)), max_len(buf_size), index(0) { }
-
-    virtual ~memory_stream() { }
-
-    virtual bool put_buf(const void* pBuf, int len)
-    {
-        if (!pBuf) {
-            //end of image
-            return true;
-        }
-        if ((size_t)len > (max_len - index)) {
-            ESP_LOGW(TAG, "JPG output overflow: %d bytes", len - (max_len - index));
-            len = max_len - index;
-        }
-        if (len) {
-            memcpy(out_buf + index, pBuf, len);
-            index += len;
-        }
-        return true;
-    }
-
-    virtual size_t get_size() const
-    {
-        return index;
-    }
-};
-
-bool fmt2jpg(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, uint8_t ** out, size_t * out_len)
-{
-    //todo: allocate proper buffer for holding JPEG data
-    //this should be enough for CIF frame size
-    int jpg_buf_len = 64*1024;
-
-
-    uint8_t * jpg_buf = (uint8_t *)_malloc(jpg_buf_len);
-    if(jpg_buf == NULL) {
-        ESP_LOGE(TAG, "JPG buffer malloc failed");
-        return false;
-    }
-    memory_stream dst_stream(jpg_buf, jpg_buf_len);
-
-    if(!convert_image(src, width, height, format, quality, &dst_stream)) {
-        free(jpg_buf);
-        return false;
-    }
-
-    *out = jpg_buf;
-    *out_len = dst_stream.get_size();
-    return true;
-}
-
-bool frame2jpg(camera_fb_t * fb, uint8_t quality, uint8_t ** out, size_t * out_len)
-{
-    return fmt2jpg(fb->buf, fb->len, fb->width, fb->height, fb->format, quality, out, out_len);
-}
--- a/code/components/esp32-camera-master/conversions/yuv.c
+++ b/code/components/esp32-camera-master/conversions/yuv.c
@@ -1,298 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "yuv.h"
-#include "esp_attr.h"
-
-typedef struct {
-        int16_t vY;
-        int16_t vVr;
-        int16_t vVg;
-        int16_t vUg;
-        int16_t vUb;
-} yuv_table_row;
-
-static const yuv_table_row yuv_table[256] = {
-    //  Y    Vr    Vg    Ug    Ub     // #
-    {  -18, -204,   50,  104, -258 }, // 0
-    {  -17, -202,   49,  103, -256 }, // 1
-    {  -16, -201,   49,  102, -254 }, // 2
-    {  -15, -199,   48,  101, -252 }, // 3
-    {  -13, -197,   48,  100, -250 }, // 4
-    {  -12, -196,   48,   99, -248 }, // 5
-    {  -11, -194,   47,   99, -246 }, // 6
-    {  -10, -193,   47,   98, -244 }, // 7
-    {   -9, -191,   46,   97, -242 }, // 8
-    {   -8, -189,   46,   96, -240 }, // 9
-    {   -6, -188,   46,   95, -238 }, // 10
-    {   -5, -186,   45,   95, -236 }, // 11
-    {   -4, -185,   45,   94, -234 }, // 12
-    {   -3, -183,   44,   93, -232 }, // 13
-    {   -2, -181,   44,   92, -230 }, // 14
-    {   -1, -180,   44,   91, -228 }, // 15
-    {    0, -178,   43,   91, -226 }, // 16
-    {    1, -177,   43,   90, -223 }, // 17
-    {    2, -175,   43,   89, -221 }, // 18
-    {    3, -173,   42,   88, -219 }, // 19
-    {    4, -172,   42,   87, -217 }, // 20
-    {    5, -170,   41,   86, -215 }, // 21
-    {    6, -169,   41,   86, -213 }, // 22
-    {    8, -167,   41,   85, -211 }, // 23
-    {    9, -165,   40,   84, -209 }, // 24
-    {   10, -164,   40,   83, -207 }, // 25
-    {   11, -162,   39,   82, -205 }, // 26
-    {   12, -161,   39,   82, -203 }, // 27
-    {   13, -159,   39,   81, -201 }, // 28
-    {   15, -158,   38,   80, -199 }, // 29
-    {   16, -156,   38,   79, -197 }, // 30
-    {   17, -154,   37,   78, -195 }, // 31
-    {   18, -153,   37,   78, -193 }, // 32
-    {   19, -151,   37,   77, -191 }, // 33
-    {   20, -150,   36,   76, -189 }, // 34
-    {   22, -148,   36,   75, -187 }, // 35
-    {   23, -146,   35,   74, -185 }, // 36
-    {   24, -145,   35,   73, -183 }, // 37
-    {   25, -143,   35,   73, -181 }, // 38
-    {   26, -142,   34,   72, -179 }, // 39
-    {   27, -140,   34,   71, -177 }, // 40
-    {   29, -138,   34,   70, -175 }, // 41
-    {   30, -137,   33,   69, -173 }, // 42
-    {   31, -135,   33,   69, -171 }, // 43
-    {   32, -134,   32,   68, -169 }, // 44
-    {   33, -132,   32,   67, -167 }, // 45
-    {   34, -130,   32,   66, -165 }, // 46
-    {   36, -129,   31,   65, -163 }, // 47
-    {   37, -127,   31,   65, -161 }, // 48
-    {   38, -126,   30,   64, -159 }, // 49
-    {   39, -124,   30,   63, -157 }, // 50
-    {   40, -122,   30,   62, -155 }, // 51
-    {   41, -121,   29,   61, -153 }, // 52
-    {   43, -119,   29,   60, -151 }, // 53
-    {   44, -118,   28,   60, -149 }, // 54
-    {   45, -116,   28,   59, -147 }, // 55
-    {   46, -114,   28,   58, -145 }, // 56
-    {   47, -113,   27,   57, -143 }, // 57
-    {   48, -111,   27,   56, -141 }, // 58
-    {   50, -110,   26,   56, -139 }, // 59
-    {   51, -108,   26,   55, -137 }, // 60
-    {   52, -106,   26,   54, -135 }, // 61
-    {   53, -105,   25,   53, -133 }, // 62
-    {   54, -103,   25,   52, -131 }, // 63
-    {   55, -102,   25,   52, -129 }, // 64
-    {   57, -100,   24,   51, -127 }, // 65
-    {   58,  -98,   24,   50, -125 }, // 66
-    {   59,  -97,   23,   49, -123 }, // 67
-    {   60,  -95,   23,   48, -121 }, // 68
-    {   61,  -94,   23,   47, -119 }, // 69
-    {   62,  -92,   22,   47, -117 }, // 70
-    {   64,  -90,   22,   46, -115 }, // 71
-    {   65,  -89,   21,   45, -113 }, // 72
-    {   66,  -87,   21,   44, -110 }, // 73
-    {   67,  -86,   21,   43, -108 }, // 74
-    {   68,  -84,   20,   43, -106 }, // 75
-    {   69,  -82,   20,   42, -104 }, // 76
-    {   71,  -81,   19,   41, -102 }, // 77
-    {   72,  -79,   19,   40, -100 }, // 78
-    {   73,  -78,   19,   39,  -98 }, // 79
-    {   74,  -76,   18,   39,  -96 }, // 80
-    {   75,  -75,   18,   38,  -94 }, // 81
-    {   76,  -73,   17,   37,  -92 }, // 82
-    {   77,  -71,   17,   36,  -90 }, // 83
-    {   79,  -70,   17,   35,  -88 }, // 84
-    {   80,  -68,   16,   34,  -86 }, // 85
-    {   81,  -67,   16,   34,  -84 }, // 86
-    {   82,  -65,   16,   33,  -82 }, // 87
-    {   83,  -63,   15,   32,  -80 }, // 88
-    {   84,  -62,   15,   31,  -78 }, // 89
-    {   86,  -60,   14,   30,  -76 }, // 90
-    {   87,  -59,   14,   30,  -74 }, // 91
-    {   88,  -57,   14,   29,  -72 }, // 92
-    {   89,  -55,   13,   28,  -70 }, // 93
-    {   90,  -54,   13,   27,  -68 }, // 94
-    {   91,  -52,   12,   26,  -66 }, // 95
-    {   93,  -51,   12,   26,  -64 }, // 96
-    {   94,  -49,   12,   25,  -62 }, // 97
-    {   95,  -47,   11,   24,  -60 }, // 98
-    {   96,  -46,   11,   23,  -58 }, // 99
-    {   97,  -44,   10,   22,  -56 }, // 100
-    {   98,  -43,   10,   21,  -54 }, // 101
-    {  100,  -41,   10,   21,  -52 }, // 102
-    {  101,  -39,    9,   20,  -50 }, // 103
-    {  102,  -38,    9,   19,  -48 }, // 104
-    {  103,  -36,    8,   18,  -46 }, // 105
-    {  104,  -35,    8,   17,  -44 }, // 106
-    {  105,  -33,    8,   17,  -42 }, // 107
-    {  107,  -31,    7,   16,  -40 }, // 108
-    {  108,  -30,    7,   15,  -38 }, // 109
-    {  109,  -28,    7,   14,  -36 }, // 110
-    {  110,  -27,    6,   13,  -34 }, // 111
-    {  111,  -25,    6,   13,  -32 }, // 112
-    {  112,  -23,    5,   12,  -30 }, // 113
-    {  114,  -22,    5,   11,  -28 }, // 114
-    {  115,  -20,    5,   10,  -26 }, // 115
-    {  116,  -19,    4,    9,  -24 }, // 116
-    {  117,  -17,    4,    8,  -22 }, // 117
-    {  118,  -15,    3,    8,  -20 }, // 118
-    {  119,  -14,    3,    7,  -18 }, // 119
-    {  121,  -12,    3,    6,  -16 }, // 120
-    {  122,  -11,    2,    5,  -14 }, // 121
-    {  123,   -9,    2,    4,  -12 }, // 122
-    {  124,   -7,    1,    4,  -10 }, // 123
-    {  125,   -6,    1,    3,   -8 }, // 124
-    {  126,   -4,    1,    2,   -6 }, // 125
-    {  128,   -3,    0,    1,   -4 }, // 126
-    {  129,   -1,    0,    0,   -2 }, // 127
-    {  130,    0,    0,    0,    0 }, // 128
-    {  131,    1,    0,    0,    2 }, // 129
-    {  132,    3,    0,   -1,    4 }, // 130
-    {  133,    4,   -1,   -2,    6 }, // 131
-    {  135,    6,   -1,   -3,    8 }, // 132
-    {  136,    7,   -1,   -4,   10 }, // 133
-    {  137,    9,   -2,   -4,   12 }, // 134
-    {  138,   11,   -2,   -5,   14 }, // 135
-    {  139,   12,   -3,   -6,   16 }, // 136
-    {  140,   14,   -3,   -7,   18 }, // 137
-    {  142,   15,   -3,   -8,   20 }, // 138
-    {  143,   17,   -4,   -8,   22 }, // 139
-    {  144,   19,   -4,   -9,   24 }, // 140
-    {  145,   20,   -5,  -10,   26 }, // 141
-    {  146,   22,   -5,  -11,   28 }, // 142
-    {  147,   23,   -5,  -12,   30 }, // 143
-    {  148,   25,   -6,  -13,   32 }, // 144
-    {  150,   27,   -6,  -13,   34 }, // 145
-    {  151,   28,   -7,  -14,   36 }, // 146
-    {  152,   30,   -7,  -15,   38 }, // 147
-    {  153,   31,   -7,  -16,   40 }, // 148
-    {  154,   33,   -8,  -17,   42 }, // 149
-    {  155,   35,   -8,  -17,   44 }, // 150
-    {  157,   36,   -8,  -18,   46 }, // 151
-    {  158,   38,   -9,  -19,   48 }, // 152
-    {  159,   39,   -9,  -20,   50 }, // 153
-    {  160,   41,  -10,  -21,   52 }, // 154
-    {  161,   43,  -10,  -21,   54 }, // 155
-    {  162,   44,  -10,  -22,   56 }, // 156
-    {  164,   46,  -11,  -23,   58 }, // 157
-    {  165,   47,  -11,  -24,   60 }, // 158
-    {  166,   49,  -12,  -25,   62 }, // 159
-    {  167,   51,  -12,  -26,   64 }, // 160
-    {  168,   52,  -12,  -26,   66 }, // 161
-    {  169,   54,  -13,  -27,   68 }, // 162
-    {  171,   55,  -13,  -28,   70 }, // 163
-    {  172,   57,  -14,  -29,   72 }, // 164
-    {  173,   59,  -14,  -30,   74 }, // 165
-    {  174,   60,  -14,  -30,   76 }, // 166
-    {  175,   62,  -15,  -31,   78 }, // 167
-    {  176,   63,  -15,  -32,   80 }, // 168
-    {  178,   65,  -16,  -33,   82 }, // 169
-    {  179,   67,  -16,  -34,   84 }, // 170
-    {  180,   68,  -16,  -34,   86 }, // 171
-    {  181,   70,  -17,  -35,   88 }, // 172
-    {  182,   71,  -17,  -36,   90 }, // 173
-    {  183,   73,  -17,  -37,   92 }, // 174
-    {  185,   75,  -18,  -38,   94 }, // 175
-    {  186,   76,  -18,  -39,   96 }, // 176
-    {  187,   78,  -19,  -39,   98 }, // 177
-    {  188,   79,  -19,  -40,  100 }, // 178
-    {  189,   81,  -19,  -41,  102 }, // 179
-    {  190,   82,  -20,  -42,  104 }, // 180
-    {  192,   84,  -20,  -43,  106 }, // 181
-    {  193,   86,  -21,  -43,  108 }, // 182
-    {  194,   87,  -21,  -44,  110 }, // 183
-    {  195,   89,  -21,  -45,  113 }, // 184
-    {  196,   90,  -22,  -46,  115 }, // 185
-    {  197,   92,  -22,  -47,  117 }, // 186
-    {  199,   94,  -23,  -47,  119 }, // 187
-    {  200,   95,  -23,  -48,  121 }, // 188
-    {  201,   97,  -23,  -49,  123 }, // 189
-    {  202,   98,  -24,  -50,  125 }, // 190
-    {  203,  100,  -24,  -51,  127 }, // 191
-    {  204,  102,  -25,  -52,  129 }, // 192
-    {  206,  103,  -25,  -52,  131 }, // 193
-    {  207,  105,  -25,  -53,  133 }, // 194
-    {  208,  106,  -26,  -54,  135 }, // 195
-    {  209,  108,  -26,  -55,  137 }, // 196
-    {  210,  110,  -26,  -56,  139 }, // 197
-    {  211,  111,  -27,  -56,  141 }, // 198
-    {  213,  113,  -27,  -57,  143 }, // 199
-    {  214,  114,  -28,  -58,  145 }, // 200
-    {  215,  116,  -28,  -59,  147 }, // 201
-    {  216,  118,  -28,  -60,  149 }, // 202
-    {  217,  119,  -29,  -60,  151 }, // 203
-    {  218,  121,  -29,  -61,  153 }, // 204
-    {  219,  122,  -30,  -62,  155 }, // 205
-    {  221,  124,  -30,  -63,  157 }, // 206
-    {  222,  126,  -30,  -64,  159 }, // 207
-    {  223,  127,  -31,  -65,  161 }, // 208
-    {  224,  129,  -31,  -65,  163 }, // 209
-    {  225,  130,  -32,  -66,  165 }, // 210
-    {  226,  132,  -32,  -67,  167 }, // 211
-    {  228,  134,  -32,  -68,  169 }, // 212
-    {  229,  135,  -33,  -69,  171 }, // 213
-    {  230,  137,  -33,  -69,  173 }, // 214
-    {  231,  138,  -34,  -70,  175 }, // 215
-    {  232,  140,  -34,  -71,  177 }, // 216
-    {  233,  142,  -34,  -72,  179 }, // 217
-    {  235,  143,  -35,  -73,  181 }, // 218
-    {  236,  145,  -35,  -73,  183 }, // 219
-    {  237,  146,  -35,  -74,  185 }, // 220
-    {  238,  148,  -36,  -75,  187 }, // 221
-    {  239,  150,  -36,  -76,  189 }, // 222
-    {  240,  151,  -37,  -77,  191 }, // 223
-    {  242,  153,  -37,  -78,  193 }, // 224
-    {  243,  154,  -37,  -78,  195 }, // 225
-    {  244,  156,  -38,  -79,  197 }, // 226
-    {  245,  158,  -38,  -80,  199 }, // 227
-    {  246,  159,  -39,  -81,  201 }, // 228
-    {  247,  161,  -39,  -82,  203 }, // 229
-    {  249,  162,  -39,  -82,  205 }, // 230
-    {  250,  164,  -40,  -83,  207 }, // 231
-    {  251,  165,  -40,  -84,  209 }, // 232
-    {  252,  167,  -41,  -85,  211 }, // 233
-    {  253,  169,  -41,  -86,  213 }, // 234
-    {  254,  170,  -41,  -86,  215 }, // 235
-    {  256,  172,  -42,  -87,  217 }, // 236
-    {  257,  173,  -42,  -88,  219 }, // 237
-    {  258,  175,  -43,  -89,  221 }, // 238
-    {  259,  177,  -43,  -90,  223 }, // 239
-    {  260,  178,  -43,  -91,  226 }, // 240
-    {  261,  180,  -44,  -91,  228 }, // 241
-    {  263,  181,  -44,  -92,  230 }, // 242
-    {  264,  183,  -44,  -93,  232 }, // 243
-    {  265,  185,  -45,  -94,  234 }, // 244
-    {  266,  186,  -45,  -95,  236 }, // 245
-    {  267,  188,  -46,  -95,  238 }, // 246
-    {  268,  189,  -46,  -96,  240 }, // 247
-    {  270,  191,  -46,  -97,  242 }, // 248
-    {  271,  193,  -47,  -98,  244 }, // 249
-    {  272,  194,  -47,  -99,  246 }, // 250
-    {  273,  196,  -48,  -99,  248 }, // 251
-    {  274,  197,  -48, -100,  250 }, // 252
-    {  275,  199,  -48, -101,  252 }, // 253
-    {  277,  201,  -49, -102,  254 }, // 254
-    {  278,  202,  -49, -103,  256 }  // 255
-};
-
-#define YUYV_CONSTRAIN(v) ((v)<0)?0:(((v)>255)?255:(v))
-
-void IRAM_ATTR yuv2rgb(uint8_t y, uint8_t u, uint8_t v, uint8_t *r, uint8_t *g, uint8_t *b)
-{
-    int16_t ri, gi, bi;
-
-    ri = yuv_table[y].vY + yuv_table[v].vVr;
-    gi = yuv_table[y].vY + yuv_table[u].vUg + yuv_table[v].vVg;
-    bi = yuv_table[y].vY + yuv_table[u].vUb;
-
-    *r = YUYV_CONSTRAIN(ri);
-    *g = YUYV_CONSTRAIN(gi);
-    *b = YUYV_CONSTRAIN(bi);
-}
--- a/code/components/esp32-camera-master/driver/camera.c
+++ b/code/components/esp32-camera-master/driver/camera.c
--- a/code/components/esp32-camera-master/driver/include/esp_camera.h
+++ b/code/components/esp32-camera-master/driver/include/esp_camera.h
@@ -1,195 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-/*
- * Example Use
- *
-    static camera_config_t camera_example_config = {
-        .pin_pwdn       = PIN_PWDN,
-        .pin_reset      = PIN_RESET,
-        .pin_xclk       = PIN_XCLK,
-        .pin_sscb_sda   = PIN_SIOD,
-        .pin_sscb_scl   = PIN_SIOC,
-        .pin_d7         = PIN_D7,
-        .pin_d6         = PIN_D6,
-        .pin_d5         = PIN_D5,
-        .pin_d4         = PIN_D4,
-        .pin_d3         = PIN_D3,
-        .pin_d2         = PIN_D2,
-        .pin_d1         = PIN_D1,
-        .pin_d0         = PIN_D0,
-        .pin_vsync      = PIN_VSYNC,
-        .pin_href       = PIN_HREF,
-        .pin_pclk       = PIN_PCLK,
-
-        .xclk_freq_hz   = 20000000,
-        .ledc_timer     = LEDC_TIMER_0,
-        .ledc_channel   = LEDC_CHANNEL_0,
-        .pixel_format   = PIXFORMAT_JPEG,
-        .frame_size     = FRAMESIZE_SVGA,
-        .jpeg_quality   = 10,
-        .fb_count       = 2
-    };
-
-    esp_err_t camera_example_init(){
-        return esp_camera_init(&camera_example_config);
-    }
-
-    esp_err_t camera_example_capture(){
-        //capture a frame
-        camera_fb_t * fb = esp_camera_fb_get();
-        if (!fb) {
-            ESP_LOGE(TAG, "Frame buffer could not be acquired");
-            return ESP_FAIL;
-        }
-
-        //replace this with your own function
-        display_image(fb->width, fb->height, fb->pixformat, fb->buf, fb->len);
-
-        //return the frame buffer back to be reused
-        esp_camera_fb_return(fb);
-
-        return ESP_OK;
-    }
-*/
-
-#pragma once
-
-#include "esp_err.h"
-#include "driver/ledc.h"
-#include "sensor.h"
-#include "sys/time.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @brief Configuration structure for camera initialization
- */
-typedef struct {
-    int pin_pwdn;                   /*!< GPIO pin for camera power down line */
-    int pin_reset;                  /*!< GPIO pin for camera reset line */
-    int pin_xclk;                   /*!< GPIO pin for camera XCLK line */
-    int pin_sscb_sda;               /*!< GPIO pin for camera SDA line */
-    int pin_sscb_scl;               /*!< GPIO pin for camera SCL line */
-    int pin_d7;                     /*!< GPIO pin for camera D7 line */
-    int pin_d6;                     /*!< GPIO pin for camera D6 line */
-    int pin_d5;                     /*!< GPIO pin for camera D5 line */
-    int pin_d4;                     /*!< GPIO pin for camera D4 line */
-    int pin_d3;                     /*!< GPIO pin for camera D3 line */
-    int pin_d2;                     /*!< GPIO pin for camera D2 line */
-    int pin_d1;                     /*!< GPIO pin for camera D1 line */
-    int pin_d0;                     /*!< GPIO pin for camera D0 line */
-    int pin_vsync;                  /*!< GPIO pin for camera VSYNC line */
-    int pin_href;                   /*!< GPIO pin for camera HREF line */
-    int pin_pclk;                   /*!< GPIO pin for camera PCLK line */
-
-    int xclk_freq_hz;               /*!< Frequency of XCLK signal, in Hz. Either 20KHz or 10KHz for OV2640 double FPS (Experimental) */
-
-    ledc_timer_t ledc_timer;        /*!< LEDC timer to be used for generating XCLK  */
-    ledc_channel_t ledc_channel;    /*!< LEDC channel to be used for generating XCLK  */
-
-    pixformat_t pixel_format;       /*!< Format of the pixel data: PIXFORMAT_ + YUV422|GRAYSCALE|RGB565|JPEG  */
-    framesize_t frame_size;         /*!< Size of the output image: FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA  */
-
-    int jpeg_quality;               /*!< Quality of JPEG output. 0-63 lower means higher quality  */
-    size_t fb_count;                /*!< Number of frame buffers to be allocated. If more than one, then each frame will be acquired (double speed)  */
-} camera_config_t;
-
-/**
- * @brief Data structure of camera frame buffer
- */
-typedef struct {
-    uint8_t * buf;              /*!< Pointer to the pixel data */
-    size_t len;                 /*!< Length of the buffer in bytes */
-    size_t width;               /*!< Width of the buffer in pixels */
-    size_t height;              /*!< Height of the buffer in pixels */
-    pixformat_t format;         /*!< Format of the pixel data */
-    struct timeval timestamp;   /*!< Timestamp since boot of the first DMA buffer of the frame */
-} camera_fb_t;
-
-#define ESP_ERR_CAMERA_BASE 0x20000
-#define ESP_ERR_CAMERA_NOT_DETECTED             (ESP_ERR_CAMERA_BASE + 1)
-#define ESP_ERR_CAMERA_FAILED_TO_SET_FRAME_SIZE (ESP_ERR_CAMERA_BASE + 2)
-#define ESP_ERR_CAMERA_FAILED_TO_SET_OUT_FORMAT (ESP_ERR_CAMERA_BASE + 3)
-#define ESP_ERR_CAMERA_NOT_SUPPORTED            (ESP_ERR_CAMERA_BASE + 4)
-
-/**
- * @brief Initialize the camera driver
- *
- * @note call camera_probe before calling this function
- *
- * This function detects and configures camera over I2C interface,
- * allocates framebuffer and DMA buffers,
- * initializes parallel I2S input, and sets up DMA descriptors.
- *
- * Currently this function can only be called once and there is
- * no way to de-initialize this module.
- *
- * @param config  Camera configuration parameters
- *
- * @return ESP_OK on success
- */
-esp_err_t esp_camera_init(const camera_config_t* config);
-
-/**
- * @brief Deinitialize the camera driver
- *
- * @return
- *      - ESP_OK on success
- *      - ESP_ERR_INVALID_STATE if the driver hasn't been initialized yet
- */
-esp_err_t esp_camera_deinit();
-
-/**
- * @brief Obtain pointer to a frame buffer.
- *
- * @return pointer to the frame buffer
- */
-camera_fb_t* esp_camera_fb_get();
-
-/**
- * @brief Return the frame buffer to be reused again.
- *
- * @param fb    Pointer to the frame buffer
- */
-void esp_camera_fb_return(camera_fb_t * fb);
-
-/**
- * @brief Get a pointer to the image sensor control structure
- *
- * @return pointer to the sensor
- */
-sensor_t * esp_camera_sensor_get();
-
-/**
- * @brief Save camera settings to non-volatile-storage (NVS)
- * 
- * @param key   A unique nvs key name for the camera settings 
- */
-esp_err_t esp_camera_save_to_nvs(const char *key);
-
-/**
- * @brief Load camera settings from non-volatile-storage (NVS)
- * 
- * @param key   A unique nvs key name for the camera settings 
- */
-esp_err_t esp_camera_load_from_nvs(const char *key);
-
-#ifdef __cplusplus
-}
-#endif
-
-#include "img_converters.h"
-
--- a/code/components/esp32-camera-master/driver/include/sensor.h
+++ b/code/components/esp32-camera-master/driver/include/sensor.h
@@ -1,193 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * Sensor abstraction layer.
- *
- */
-#ifndef __SENSOR_H__
-#define __SENSOR_H__
-#include <stdint.h>
-#include <stdbool.h>
-
-#define NT99141_PID     (0x14)
-#define OV9650_PID     (0x96)
-#define OV7725_PID     (0x77)
-#define OV2640_PID     (0x26)
-#define OV3660_PID     (0x36)
-#define OV5640_PID     (0x56)
-#define OV7670_PID     (0x76)
-
-typedef enum {
-    PIXFORMAT_RGB565,    // 2BPP/RGB565
-    PIXFORMAT_YUV422,    // 2BPP/YUV422
-    PIXFORMAT_GRAYSCALE, // 1BPP/GRAYSCALE
-    PIXFORMAT_JPEG,      // JPEG/COMPRESSED
-    PIXFORMAT_RGB888,    // 3BPP/RGB888
-    PIXFORMAT_RAW,       // RAW
-    PIXFORMAT_RGB444,    // 3BP2P/RGB444
-    PIXFORMAT_RGB555,    // 3BP2P/RGB555
-} pixformat_t;
-
-typedef enum {
-    FRAMESIZE_96X96,    // 96x96
-    FRAMESIZE_QQVGA,    // 160x120
-    FRAMESIZE_QCIF,     // 176x144
-    FRAMESIZE_HQVGA,    // 240x176
-    FRAMESIZE_240X240,  // 240x240
-    FRAMESIZE_QVGA,     // 320x240
-    FRAMESIZE_CIF,      // 400x296
-    FRAMESIZE_HVGA,     // 480x320
-    FRAMESIZE_VGA,      // 640x480
-    FRAMESIZE_SVGA,     // 800x600
-    FRAMESIZE_XGA,      // 1024x768
-    FRAMESIZE_HD,       // 1280x720
-    FRAMESIZE_SXGA,     // 1280x1024
-    FRAMESIZE_UXGA,     // 1600x1200
-    // 3MP Sensors
-    FRAMESIZE_FHD,      // 1920x1080
-    FRAMESIZE_P_HD,     //  720x1280
-    FRAMESIZE_P_3MP,    //  864x1536
-    FRAMESIZE_QXGA,     // 2048x1536
-    // 5MP Sensors
-    FRAMESIZE_QHD,      // 2560x1440
-    FRAMESIZE_WQXGA,    // 2560x1600
-    FRAMESIZE_P_FHD,    // 1080x1920
-    FRAMESIZE_QSXGA,    // 2560x1920
-    FRAMESIZE_INVALID
-} framesize_t;
-
-typedef enum {
-    ASPECT_RATIO_4X3,
-    ASPECT_RATIO_3X2,
-    ASPECT_RATIO_16X10,
-    ASPECT_RATIO_5X3,
-    ASPECT_RATIO_16X9,
-    ASPECT_RATIO_21X9,
-    ASPECT_RATIO_5X4,
-    ASPECT_RATIO_1X1,
-    ASPECT_RATIO_9X16
-} aspect_ratio_t;
-
-typedef enum {
-    GAINCEILING_2X,
-    GAINCEILING_4X,
-    GAINCEILING_8X,
-    GAINCEILING_16X,
-    GAINCEILING_32X,
-    GAINCEILING_64X,
-    GAINCEILING_128X,
-} gainceiling_t;
-
-typedef struct {
-        uint16_t max_width;
-        uint16_t max_height;
-        uint16_t start_x;
-        uint16_t start_y;
-        uint16_t end_x;
-        uint16_t end_y;
-        uint16_t offset_x;
-        uint16_t offset_y;
-        uint16_t total_x;
-        uint16_t total_y;
-} ratio_settings_t;
-
-typedef struct {
-        const uint16_t width;
-        const uint16_t height;
-        const aspect_ratio_t aspect_ratio;
-} resolution_info_t;
-
-// Resolution table (in sensor.c)
-extern const resolution_info_t resolution[];
-
-typedef struct {
-    uint8_t MIDH;
-    uint8_t MIDL;
-    uint8_t PID;
-    uint8_t VER;
-} sensor_id_t;
-
-typedef struct {
-    framesize_t framesize;//0 - 10
-    bool scale;
-    bool binning;
-    uint8_t quality;//0 - 63
-    int8_t brightness;//-2 - 2
-    int8_t contrast;//-2 - 2
-    int8_t saturation;//-2 - 2
-    int8_t sharpness;//-2 - 2
-    uint8_t denoise;
-    uint8_t special_effect;//0 - 6
-    uint8_t wb_mode;//0 - 4
-    uint8_t awb;
-    uint8_t awb_gain;
-    uint8_t aec;
-    uint8_t aec2;
-    int8_t ae_level;//-2 - 2
-    uint16_t aec_value;//0 - 1200
-    uint8_t agc;
-    uint8_t agc_gain;//0 - 30
-    uint8_t gainceiling;//0 - 6
-    uint8_t bpc;
-    uint8_t wpc;
-    uint8_t raw_gma;
-    uint8_t lenc;
-    uint8_t hmirror;
-    uint8_t vflip;
-    uint8_t dcw;
-    uint8_t colorbar;
-} camera_status_t;
-
-typedef struct _sensor sensor_t;
-typedef struct _sensor {
-    sensor_id_t id;             // Sensor ID.
-    uint8_t  slv_addr;          // Sensor I2C slave address.
-    pixformat_t pixformat;
-    camera_status_t status;
-    int xclk_freq_hz;
-
-    // Sensor function pointers
-    int  (*init_status)         (sensor_t *sensor);
-    int  (*reset)               (sensor_t *sensor);
-    int  (*set_pixformat)       (sensor_t *sensor, pixformat_t pixformat);
-    int  (*set_framesize)       (sensor_t *sensor, framesize_t framesize);
-    int  (*set_contrast)        (sensor_t *sensor, int level);
-    int  (*set_brightness)      (sensor_t *sensor, int level);
-    int  (*set_saturation)      (sensor_t *sensor, int level);
-    int  (*set_sharpness)       (sensor_t *sensor, int level);
-    int  (*set_denoise)         (sensor_t *sensor, int level);
-    int  (*set_gainceiling)     (sensor_t *sensor, gainceiling_t gainceiling);
-    int  (*set_quality)         (sensor_t *sensor, int quality);
-    int  (*set_colorbar)        (sensor_t *sensor, int enable);
-    int  (*set_whitebal)        (sensor_t *sensor, int enable);
-    int  (*set_gain_ctrl)       (sensor_t *sensor, int enable);
-    int  (*set_exposure_ctrl)   (sensor_t *sensor, int enable);
-    int  (*set_hmirror)         (sensor_t *sensor, int enable);
-    int  (*set_vflip)           (sensor_t *sensor, int enable);
-
-    int  (*set_aec2)            (sensor_t *sensor, int enable);
-    int  (*set_awb_gain)        (sensor_t *sensor, int enable);
-    int  (*set_agc_gain)        (sensor_t *sensor, int gain);
-    int  (*set_aec_value)       (sensor_t *sensor, int gain);
-
-    int  (*set_special_effect)  (sensor_t *sensor, int effect);
-    int  (*set_wb_mode)         (sensor_t *sensor, int mode);
-    int  (*set_ae_level)        (sensor_t *sensor, int level);
-
-    int  (*set_dcw)             (sensor_t *sensor, int enable);
-    int  (*set_bpc)             (sensor_t *sensor, int enable);
-    int  (*set_wpc)             (sensor_t *sensor, int enable);
-
-    int  (*set_raw_gma)         (sensor_t *sensor, int enable);
-    int  (*set_lenc)            (sensor_t *sensor, int enable);
-
-    int  (*get_reg)             (sensor_t *sensor, int reg, int mask);
-    int  (*set_reg)             (sensor_t *sensor, int reg, int mask, int value);
-    int  (*set_res_raw)         (sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning);
-    int  (*set_pll)             (sensor_t *sensor, int bypass, int mul, int sys, int root, int pre, int seld5, int pclken, int pclk);
-    int  (*set_xclk)            (sensor_t *sensor, int timer, int xclk);
-} sensor_t;
-
-#endif /* __SENSOR_H__ */
--- a/code/components/esp32-camera-master/driver/private_include/camera_common.h
+++ b/code/components/esp32-camera-master/driver/private_include/camera_common.h
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "esp_err.h"
-#include "esp_intr_alloc.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/semphr.h"
-#include "freertos/task.h"
-#include "esp_camera.h"
-#include "sensor.h"
-
-#include "esp_system.h"
-#if ESP_IDF_VERSION_MAJOR >= 4 // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/lldesc.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/lldesc.h"
-#endif
-
-typedef union {
-    struct {
-        uint8_t sample2;
-        uint8_t unused2;
-        uint8_t sample1;
-        uint8_t unused1;
-    };
-    uint32_t val;
-} dma_elem_t;
-
-typedef enum {
-    /* camera sends byte sequence: s1, s2, s3, s4, ...
-     * fifo receives: 00 s1 00 s2, 00 s2 00 s3, 00 s3 00 s4, ...
-     */
-    SM_0A0B_0B0C = 0,
-    /* camera sends byte sequence: s1, s2, s3, s4, ...
-     * fifo receives: 00 s1 00 s2, 00 s3 00 s4, ...
-     */
-    SM_0A0B_0C0D = 1,
-    /* camera sends byte sequence: s1, s2, s3, s4, ...
-     * fifo receives: 00 s1 00 00, 00 s2 00 00, 00 s3 00 00, ...
-     */
-    SM_0A00_0B00 = 3,
-} i2s_sampling_mode_t;
-
--- a/code/components/esp32-camera-master/driver/private_include/sccb.h
+++ b/code/components/esp32-camera-master/driver/private_include/sccb.h
@@ -1,18 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * SCCB (I2C like) driver.
- *
- */
-#ifndef __SCCB_H__
-#define __SCCB_H__
-#include <stdint.h>
-int SCCB_Init(int pin_sda, int pin_scl);
-uint8_t SCCB_Probe();
-uint8_t SCCB_Read(uint8_t slv_addr, uint8_t reg);
-uint8_t SCCB_Write(uint8_t slv_addr, uint8_t reg, uint8_t data);
-uint8_t SCCB_Read16(uint8_t slv_addr, uint16_t reg);
-uint8_t SCCB_Write16(uint8_t slv_addr, uint16_t reg, uint8_t data);
-#endif // __SCCB_H__
--- a/code/components/esp32-camera-master/driver/private_include/xclk.h
+++ b/code/components/esp32-camera-master/driver/private_include/xclk.h
@@ -1,7 +0,0 @@
-#pragma once
-
-#include "camera_common.h"
-
-esp_err_t camera_enable_out_clock();
-
-void camera_disable_out_clock();
--- a/code/components/esp32-camera-master/driver/sccb.c
+++ b/code/components/esp32-camera-master/driver/sccb.c
@@ -1,167 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * SCCB (I2C like) driver.
- *
- */
-#include <stdbool.h>
-#include <string.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#include "sccb.h"
-#include <stdio.h>
-#include "sdkconfig.h"
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#else
-#include "esp_log.h"
-static const char* TAG = "sccb";
-#endif
-
-#define LITTLETOBIG(x)          ((x<<8)|(x>>8))
-
-#include "driver/i2c.h"
-
-#define SCCB_FREQ               100000           /*!< I2C master frequency*/
-#define WRITE_BIT               I2C_MASTER_WRITE /*!< I2C master write */
-#define READ_BIT                I2C_MASTER_READ  /*!< I2C master read */
-#define ACK_CHECK_EN            0x1              /*!< I2C master will check ack from slave*/
-#define ACK_CHECK_DIS           0x0              /*!< I2C master will not check ack from slave */
-#define ACK_VAL                 0x0              /*!< I2C ack value */
-#define NACK_VAL                0x1              /*!< I2C nack value */
-#if CONFIG_SCCB_HARDWARE_I2C_PORT1
-const int SCCB_I2C_PORT         = 1;
-#else
-const int SCCB_I2C_PORT         = 0;
-#endif
-static uint8_t ESP_SLAVE_ADDR   = 0x3c;
-
-int SCCB_Init(int pin_sda, int pin_scl)
-{
-    ESP_LOGI(TAG, "pin_sda %d pin_scl %d\n", pin_sda, pin_scl);
-    //log_i("SCCB_Init start");
-    i2c_config_t conf;
-    memset(&conf, 0, sizeof(i2c_config_t));
-    conf.mode = I2C_MODE_MASTER;
-    conf.sda_io_num = pin_sda;
-    conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
-    conf.scl_io_num = pin_scl;
-    conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
-    conf.master.clk_speed = SCCB_FREQ;
-
-    i2c_param_config(SCCB_I2C_PORT, &conf);
-    i2c_driver_install(SCCB_I2C_PORT, conf.mode, 0, 0, 0);
-    return 0;
-}
-
-uint8_t SCCB_Probe()
-{
-    uint8_t slave_addr = 0x0;
-    while(slave_addr < 0x7f) {
-        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-        i2c_master_start(cmd);
-        i2c_master_write_byte(cmd, ( slave_addr << 1 ) | WRITE_BIT, ACK_CHECK_EN);
-        i2c_master_stop(cmd);
-        esp_err_t ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-        i2c_cmd_link_delete(cmd);
-        if( ret == ESP_OK) {
-            ESP_SLAVE_ADDR = slave_addr;
-            return ESP_SLAVE_ADDR;
-        }
-        slave_addr++;
-    }
-    return ESP_SLAVE_ADDR;
-}
-
-uint8_t SCCB_Read(uint8_t slv_addr, uint8_t reg)
-{
-    uint8_t data=0;
-    esp_err_t ret = ESP_FAIL;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | WRITE_BIT, ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg, ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) return -1;
-    cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | READ_BIT, ACK_CHECK_EN);
-    i2c_master_read_byte(cmd, &data, NACK_VAL);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) {
-        ESP_LOGE(TAG, "SCCB_Read Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, data, ret);
-    }
-    return data;
-}
-
-uint8_t SCCB_Write(uint8_t slv_addr, uint8_t reg, uint8_t data)
-{
-    esp_err_t ret = ESP_FAIL;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | WRITE_BIT, ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg, ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, data, ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) {
-        ESP_LOGE(TAG, "SCCB_Write Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, data, ret);
-    }
-    return ret == ESP_OK ? 0 : -1;
-}
-
-uint8_t SCCB_Read16(uint8_t slv_addr, uint16_t reg)
-{
-    uint8_t data=0;
-    esp_err_t ret = ESP_FAIL;
-    uint16_t reg_htons = LITTLETOBIG(reg);
-    uint8_t *reg_u8 = (uint8_t *)&reg_htons;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | WRITE_BIT, ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg_u8[0], ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg_u8[1], ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) return -1;
-    cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | READ_BIT, ACK_CHECK_EN);
-    i2c_master_read_byte(cmd, &data, NACK_VAL);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) {
-        ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, data);
-    }
-    return data;
-}
-
-uint8_t SCCB_Write16(uint8_t slv_addr, uint16_t reg, uint8_t data)
-{
-    static uint16_t i = 0;
-    esp_err_t ret = ESP_FAIL;
-    uint16_t reg_htons = LITTLETOBIG(reg);
-    uint8_t *reg_u8 = (uint8_t *)&reg_htons;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, ( slv_addr << 1 ) | WRITE_BIT, ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg_u8[0], ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, reg_u8[1], ACK_CHECK_EN);
-    i2c_master_write_byte(cmd, data, ACK_CHECK_EN);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(SCCB_I2C_PORT, cmd, 1000 / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret != ESP_OK) {
-        ESP_LOGE(TAG, "W [%04x]=%02x %d fail\n", reg, data, i++);
-    }
-    return ret == ESP_OK ? 0 : -1;
-}
--- a/code/components/esp32-camera-master/driver/sensor.c
+++ b/code/components/esp32-camera-master/driver/sensor.c
@@ -1,28 +0,0 @@
-#include "sensor.h"
-
-const resolution_info_t resolution[FRAMESIZE_INVALID] = {
-    {   96,   96, ASPECT_RATIO_1X1   }, /* 96x96 */
-    {  160,  120, ASPECT_RATIO_4X3   }, /* QQVGA */
-    {  176,  144, ASPECT_RATIO_5X4   }, /* QCIF  */
-    {  240,  176, ASPECT_RATIO_4X3   }, /* HQVGA */
-    {  240,  240, ASPECT_RATIO_1X1   }, /* 240x240 */
-    {  320,  240, ASPECT_RATIO_4X3   }, /* QVGA  */
-    {  400,  296, ASPECT_RATIO_4X3   }, /* CIF   */
-    {  480,  320, ASPECT_RATIO_3X2   }, /* HVGA  */
-    {  640,  480, ASPECT_RATIO_4X3   }, /* VGA   */
-    {  800,  600, ASPECT_RATIO_4X3   }, /* SVGA  */
-    { 1024,  768, ASPECT_RATIO_4X3   }, /* XGA   */
-    { 1280,  720, ASPECT_RATIO_16X9  }, /* HD    */
-    { 1280, 1024, ASPECT_RATIO_5X4   }, /* SXGA  */
-    { 1600, 1200, ASPECT_RATIO_4X3   }, /* UXGA  */
-    // 3MP Sensors
-    { 1920, 1080, ASPECT_RATIO_16X9  }, /* FHD   */
-    {  720, 1280, ASPECT_RATIO_9X16  }, /* Portrait HD   */
-    {  864, 1536, ASPECT_RATIO_9X16  }, /* Portrait 3MP   */
-    { 2048, 1536, ASPECT_RATIO_4X3   }, /* QXGA  */
-    // 5MP Sensors
-    { 2560, 1440, ASPECT_RATIO_16X9  }, /* QHD    */
-    { 2560, 1600, ASPECT_RATIO_16X10 }, /* WQXGA  */
-    { 1088, 1920, ASPECT_RATIO_9X16  }, /* Portrait FHD   */
-    { 2560, 1920, ASPECT_RATIO_4X3   }, /* QSXGA  */
-};
--- a/code/components/esp32-camera-master/driver/xclk.c
+++ b/code/components/esp32-camera-master/driver/xclk.c
@@ -1,61 +0,0 @@
-#include "driver/gpio.h"
-#include "driver/ledc.h"
-#include "esp_err.h"
-#include "esp_log.h"
-#include "esp_system.h"
-#include "xclk.h"
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#else
-#include "esp_log.h"
-static const char* TAG = "camera_xclk";
-#endif
-
-esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz)
-{
-    ledc_timer_config_t timer_conf;
-    timer_conf.duty_resolution = 2;
-    timer_conf.freq_hz = xclk_freq_hz;
-    timer_conf.speed_mode = LEDC_HIGH_SPEED_MODE;
-#if ESP_IDF_VERSION_MAJOR >= 4
-    timer_conf.clk_cfg = LEDC_AUTO_CLK;
-#endif
-    timer_conf.timer_num = (ledc_timer_t)ledc_timer;
-    esp_err_t err = ledc_timer_config(&timer_conf);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "ledc_timer_config failed for freq %d, rc=%x", xclk_freq_hz, err);
-    }
-    return err;
-}
-
-esp_err_t camera_enable_out_clock(camera_config_t* config)
-{
-    periph_module_enable(PERIPH_LEDC_MODULE);
-
-    esp_err_t err = xclk_timer_conf(config->ledc_timer, config->xclk_freq_hz);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "ledc_timer_config failed, rc=%x", err);
-        return err;
-    }
-
-    ledc_channel_config_t ch_conf;
-    ch_conf.gpio_num = config->pin_xclk;
-    ch_conf.speed_mode = LEDC_HIGH_SPEED_MODE;
-    ch_conf.channel = config->ledc_channel;
-    ch_conf.intr_type = LEDC_INTR_DISABLE;
-    ch_conf.timer_sel = config->ledc_timer;
-    ch_conf.duty = 2;
-    ch_conf.hpoint = 0;
-    err = ledc_channel_config(&ch_conf);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "ledc_channel_config failed, rc=%x", err);
-        return err;
-    }
-    return ESP_OK;
-}
-
-void camera_disable_out_clock()
-{
-    periph_module_disable(PERIPH_LEDC_MODULE);
-}
--- a/code/components/esp32-camera-master/examples/take_picture.c
+++ b/code/components/esp32-camera-master/examples/take_picture.c
@@ -1,150 +0,0 @@
-/**
- * This example takes a picture every 5s and print its size on serial monitor.
- */
-
-// =============================== SETUP ======================================
-
-// 1. Board setup (Uncomment):
-// #define BOARD_WROVER_KIT
-// #define BOARD_ESP32CAM_AITHINKER
-
-/**
- * 2. Kconfig setup
- * 
- * If you have a Kconfig file, copy the content from
- *  https://github.com/espressif/esp32-camera/blob/master/Kconfig into it.
- * In case you haven't, copy and paste this Kconfig file inside the src directory.
- * This Kconfig file has definitions that allows more control over the camera and
- * how it will be initialized.
- */
-
-/**
- * 3. Enable PSRAM on sdkconfig:
- * 
- * CONFIG_ESP32_SPIRAM_SUPPORT=y
- * 
- * More info on
- * https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-esp32-spiram-support
- */
-
-// ================================ CODE ======================================
-
-#include <esp_event.h>
-#include <esp_log.h>
-#include <esp_system.h>
-#include <nvs_flash.h>
-#include <sys/param.h>
-#include <string.h>
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include "esp_camera.h"
-
-// WROVER-KIT PIN Map
-#ifdef BOARD_WROVER_KIT
-
-#define CAM_PIN_PWDN -1  //power down is not used
-#define CAM_PIN_RESET -1 //software reset will be performed
-#define CAM_PIN_XCLK 21
-#define CAM_PIN_SIOD 26
-#define CAM_PIN_SIOC 27
-
-#define CAM_PIN_D7 35
-#define CAM_PIN_D6 34
-#define CAM_PIN_D5 39
-#define CAM_PIN_D4 36
-#define CAM_PIN_D3 19
-#define CAM_PIN_D2 18
-#define CAM_PIN_D1 5
-#define CAM_PIN_D0 4
-#define CAM_PIN_VSYNC 25
-#define CAM_PIN_HREF 23
-#define CAM_PIN_PCLK 22
-
-#endif
-
-// ESP32Cam (AiThinker) PIN Map
-#ifdef BOARD_ESP32CAM_AITHINKER
-
-#define CAM_PIN_PWDN 32
-#define CAM_PIN_RESET -1 //software reset will be performed
-#define CAM_PIN_XCLK 0
-#define CAM_PIN_SIOD 26
-#define CAM_PIN_SIOC 27
-
-#define CAM_PIN_D7 35
-#define CAM_PIN_D6 34
-#define CAM_PIN_D5 39
-#define CAM_PIN_D4 36
-#define CAM_PIN_D3 21
-#define CAM_PIN_D2 19
-#define CAM_PIN_D1 18
-#define CAM_PIN_D0 5
-#define CAM_PIN_VSYNC 25
-#define CAM_PIN_HREF 23
-#define CAM_PIN_PCLK 22
-
-#endif
-
-static const char *TAG = "example:take_picture";
-
-static camera_config_t camera_config = {
-    .pin_pwdn = CAM_PIN_PWDN,
-    .pin_reset = CAM_PIN_RESET,
-    .pin_xclk = CAM_PIN_XCLK,
-    .pin_sscb_sda = CAM_PIN_SIOD,
-    .pin_sscb_scl = CAM_PIN_SIOC,
-
-    .pin_d7 = CAM_PIN_D7,
-    .pin_d6 = CAM_PIN_D6,
-    .pin_d5 = CAM_PIN_D5,
-    .pin_d4 = CAM_PIN_D4,
-    .pin_d3 = CAM_PIN_D3,
-    .pin_d2 = CAM_PIN_D2,
-    .pin_d1 = CAM_PIN_D1,
-    .pin_d0 = CAM_PIN_D0,
-    .pin_vsync = CAM_PIN_VSYNC,
-    .pin_href = CAM_PIN_HREF,
-    .pin_pclk = CAM_PIN_PCLK,
-
-    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
-    .xclk_freq_hz = 20000000,
-    .ledc_timer = LEDC_TIMER_0,
-    .ledc_channel = LEDC_CHANNEL_0,
-
-    .pixel_format = PIXFORMAT_JPEG, //YUV422,GRAYSCALE,RGB565,JPEG
-    .frame_size = FRAMESIZE_VGA,    //QQVGA-UXGA Do not use sizes above QVGA when not JPEG
-
-    .jpeg_quality = 12, //0-63 lower number means higher quality
-    .fb_count = 1       //if more than one, i2s runs in continuous mode. Use only with JPEG
-};
-
-static esp_err_t init_camera()
-{
-    //initialize the camera
-    esp_err_t err = esp_camera_init(&camera_config);
-    if (err != ESP_OK)
-    {
-        ESP_LOGE(TAG, "Camera Init Failed");
-        return err;
-    }
-
-    return ESP_OK;
-}
-
-void app_main()
-{
-    init_camera();
-
-    while (1)
-    {
-        ESP_LOGI(TAG, "Taking picture...");
-        camera_fb_t *pic = esp_camera_fb_get();
-
-        // use pic->buf to access the image
-        ESP_LOGI(TAG, "Picture taken! Its size was: %zu bytes", pic->len);
-
-        vTaskDelay(5000 / portTICK_RATE_MS);
-    }
-}
--- a/code/components/esp32-camera-master/idf_component.yml
+++ b/code/components/esp32-camera-master/idf_component.yml
@@ -1,3 +0,0 @@
-version: "1.0.0"
-description: This package hosts ESP32 compatible driver for OV2640 image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
-url: https://github.com/espressif/esp32-camera
--- a/code/components/esp32-camera-master/library.json
+++ b/code/components/esp32-camera-master/library.json
@@ -1,25 +0,0 @@
-{
-  "name": "esp32-camera",
-  "version": "1.0.0",
-  "keywords": "esp32, camera, espressif, esp32-cam",
-  "description": "ESP32 compatible driver for OV2640, OV3660, OV5640, OV7670 and OV7725 image sensors.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/espressif/esp32-camera"
-  },
-  "frameworks": "espidf",
-  "platforms": "*",
-  "build": {
-    "flags": [
-      "-Idriver/include",
-      "-Iconversions/include",
-      "-Idriver/private_include",
-      "-Iconversions/private_include",
-      "-Isensors/private_include",
-      "-fno-rtti"
-    ],
-    "includeDir": ".",
-    "srcDir": ".",
-    "srcFilter": ["-<*>", "+<driver>", "+<conversions>", "+<sensors>"]
-  }
-}
--- a/code/components/esp32-camera-master/sensors/nt99141.c
+++ b/code/components/esp32-camera-master/sensors/nt99141.c
--- a/code/components/esp32-camera-master/sensors/ov2640.c
+++ b/code/components/esp32-camera-master/sensors/ov2640.c
@@ -1,580 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV2640 driver.
- *
- */
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include "sccb.h"
-#include "ov2640.h"
-#include "ov2640_regs.h"
-#include "ov2640_settings.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#else
-#include "esp_log.h"
-static const char* TAG = "ov2640";
-#endif
-
-static volatile ov2640_bank_t reg_bank = BANK_MAX;
-static int set_bank(sensor_t *sensor, ov2640_bank_t bank)
-{
-    int res = 0;
-    if (bank != reg_bank) {
-        reg_bank = bank;
-        res = SCCB_Write(sensor->slv_addr, BANK_SEL, bank);
-    }
-    return res;
-}
-
-static int write_regs(sensor_t *sensor, const uint8_t (*regs)[2])
-{
-    int i=0, res = 0;
-    while (regs[i][0]) {
-        if (regs[i][0] == BANK_SEL) {
-            res = set_bank(sensor, regs[i][1]);
-        } else {
-            res = SCCB_Write(sensor->slv_addr, regs[i][0], regs[i][1]);
-        }
-        if (res) {
-            return res;
-        }
-        i++;
-    }
-    return res;
-}
-
-static int write_reg(sensor_t *sensor, ov2640_bank_t bank, uint8_t reg, uint8_t value)
-{
-    int ret = set_bank(sensor, bank);
-    if(!ret) {
-        ret = SCCB_Write(sensor->slv_addr, reg, value);
-    }
-    return ret;
-}
-
-static int set_reg_bits(sensor_t *sensor, uint8_t bank, uint8_t reg, uint8_t offset, uint8_t mask, uint8_t value)
-{
-    int ret = 0;
-    uint8_t c_value, new_value;
-
-    ret = set_bank(sensor, bank);
-    if(ret) {
-        return ret;
-    }
-    c_value = SCCB_Read(sensor->slv_addr, reg);
-    new_value = (c_value & ~(mask << offset)) | ((value & mask) << offset);
-    ret = SCCB_Write(sensor->slv_addr, reg, new_value);
-    return ret;
-}
-
-static int read_reg(sensor_t *sensor, ov2640_bank_t bank, uint8_t reg)
-{
-    if(set_bank(sensor, bank)){
-        return 0;
-    }
-    return SCCB_Read(sensor->slv_addr, reg);
-}
-
-static uint8_t get_reg_bits(sensor_t *sensor, uint8_t bank, uint8_t reg, uint8_t offset, uint8_t mask)
-{
-    return (read_reg(sensor, bank, reg) >> offset) & mask;
-}
-
-static int write_reg_bits(sensor_t *sensor, uint8_t bank, uint8_t reg, uint8_t mask, int enable)
-{
-    return set_reg_bits(sensor, bank, reg, 0, mask, enable?mask:0);
-}
-
-#define WRITE_REGS_OR_RETURN(regs) ret = write_regs(sensor, regs); if(ret){return ret;}
-#define WRITE_REG_OR_RETURN(bank, reg, val) ret = write_reg(sensor, bank, reg, val); if(ret){return ret;}
-#define SET_REG_BITS_OR_RETURN(bank, reg, offset, mask, val) ret = set_reg_bits(sensor, bank, reg, offset, mask, val); if(ret){return ret;}
-
-static int reset(sensor_t *sensor)
-{
-    int ret = 0;
-    WRITE_REG_OR_RETURN(BANK_SENSOR, COM7, COM7_SRST);
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-    WRITE_REGS_OR_RETURN(ov2640_settings_cif);
-    return ret;
-}
-
-static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
-{
-    int ret = 0;
-    sensor->pixformat = pixformat;
-    switch (pixformat) {
-    case PIXFORMAT_RGB565:
-    case PIXFORMAT_RGB888:
-        WRITE_REGS_OR_RETURN(ov2640_settings_rgb565);
-        break;
-    case PIXFORMAT_YUV422:
-    case PIXFORMAT_GRAYSCALE:
-        WRITE_REGS_OR_RETURN(ov2640_settings_yuv422);
-        break;
-    case PIXFORMAT_JPEG:
-        WRITE_REGS_OR_RETURN(ov2640_settings_jpeg3);
-        break;
-    default:
-        ret = -1;
-        break;
-    }
-    if(!ret) {
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-    }
-
-    return ret;
-}
-
-static int set_window(sensor_t *sensor, ov2640_sensor_mode_t mode, int offset_x, int offset_y, int max_x, int max_y, int w, int h){
-    int ret = 0;
-    const uint8_t (*regs)[2];
-    ov2640_clk_t c;
-    c.reserved = 0;
-
-    max_x /= 4;
-    max_y /= 4;
-    w /= 4;
-    h /= 4;
-    uint8_t win_regs[][2] = {
-        {BANK_SEL, BANK_DSP},
-        {HSIZE, max_x & 0xFF},
-        {VSIZE, max_y & 0xFF},
-        {XOFFL, offset_x & 0xFF},
-        {YOFFL, offset_y & 0xFF},
-        {VHYX, ((max_y >> 1) & 0X80) | ((offset_y >> 4) & 0X70) | ((max_x >> 5) & 0X08) | ((offset_y >> 8) & 0X07)},
-        {TEST, (max_x >> 2) & 0X80},
-        {ZMOW, (w)&0xFF},
-        {ZMOH, (h)&0xFF},
-        {ZMHH, ((h>>6)&0x04)|((w>>8)&0x03)},
-        {0, 0}
-    };
-
-    c.pclk_auto = 0;
-    c.pclk_div = 8;
-    c.clk_2x = 0;
-    c.clk_div = 0;
-
-    if(sensor->pixformat != PIXFORMAT_JPEG){
-        c.pclk_auto = 1;
-        c.clk_div = 7;
-    }
-
-    if (mode == OV2640_MODE_CIF) {
-        regs = ov2640_settings_to_cif;
-        if(sensor->pixformat != PIXFORMAT_JPEG){
-            c.clk_div = 3;
-        }
-    } else if (mode == OV2640_MODE_SVGA) {
-        regs = ov2640_settings_to_svga;
-    } else {
-        regs = ov2640_settings_to_uxga;
-        c.pclk_div = 12;
-    }
-
-    WRITE_REG_OR_RETURN(BANK_DSP, R_BYPASS, R_BYPASS_DSP_BYPAS);
-    WRITE_REGS_OR_RETURN(regs);
-    WRITE_REGS_OR_RETURN(win_regs);
-    WRITE_REG_OR_RETURN(BANK_SENSOR, CLKRC, c.clk);
-    WRITE_REG_OR_RETURN(BANK_DSP, R_DVP_SP, c.pclk);
-    WRITE_REG_OR_RETURN(BANK_DSP, R_BYPASS, R_BYPASS_DSP_EN);
-
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-    //required when changing resolution
-    set_pixformat(sensor, sensor->pixformat);
-
-    return ret;
-}
-
-static int set_framesize(sensor_t *sensor, framesize_t framesize)
-{
-    int ret = 0;
-    uint16_t w = resolution[framesize].width;
-    uint16_t h = resolution[framesize].height;
-    aspect_ratio_t ratio = resolution[framesize].aspect_ratio;
-    uint16_t max_x = ratio_table[ratio].max_x;
-    uint16_t max_y = ratio_table[ratio].max_y;
-    uint16_t offset_x = ratio_table[ratio].offset_x;
-    uint16_t offset_y = ratio_table[ratio].offset_y;
-    ov2640_sensor_mode_t mode = OV2640_MODE_UXGA;
-
-    sensor->status.framesize = framesize;
-
-
-
-    if (framesize <= FRAMESIZE_CIF) {
-        mode = OV2640_MODE_CIF;
-        max_x /= 4;
-        max_y /= 4;
-        offset_x /= 4;
-        offset_y /= 4;
-        if(max_y > 296){
-            max_y = 296;
-        }
-    } else if (framesize <= FRAMESIZE_SVGA) {
-        mode = OV2640_MODE_SVGA;
-        max_x /= 2;
-        max_y /= 2;
-        offset_x /= 2;
-        offset_y /= 2;
-    }
-
-    ret = set_window(sensor, mode, offset_x, offset_y, max_x, max_y, w, h);
-    return ret;
-}
-
-static int set_contrast(sensor_t *sensor, int level)
-{
-    int ret=0;
-    level += 3;
-    if (level <= 0 || level > NUM_CONTRAST_LEVELS) {
-        return -1;
-    }
-    sensor->status.contrast = level-3;
-    for (int i=0; i<7; i++) {
-        WRITE_REG_OR_RETURN(BANK_DSP, contrast_regs[0][i], contrast_regs[level][i]);
-    }
-    return ret;
-}
-
-static int set_brightness(sensor_t *sensor, int level)
-{
-    int ret=0;
-    level += 3;
-    if (level <= 0 || level > NUM_BRIGHTNESS_LEVELS) {
-        return -1;
-    }
-    sensor->status.brightness = level-3;
-    for (int i=0; i<5; i++) {
-        WRITE_REG_OR_RETURN(BANK_DSP, brightness_regs[0][i], brightness_regs[level][i]);
-    }
-    return ret;
-}
-
-static int set_saturation(sensor_t *sensor, int level)
-{
-    int ret=0;
-    level += 3;
-    if (level <= 0 || level > NUM_SATURATION_LEVELS) {
-        return -1;
-    }
-    sensor->status.saturation = level-3;
-    for (int i=0; i<5; i++) {
-        WRITE_REG_OR_RETURN(BANK_DSP, saturation_regs[0][i], saturation_regs[level][i]);
-    }
-    return ret;
-}
-
-static int set_special_effect(sensor_t *sensor, int effect)
-{
-    int ret=0;
-    effect++;
-    if (effect <= 0 || effect > NUM_SPECIAL_EFFECTS) {
-        return -1;
-    }
-    sensor->status.special_effect = effect-1;
-    for (int i=0; i<5; i++) {
-        WRITE_REG_OR_RETURN(BANK_DSP, special_effects_regs[0][i], special_effects_regs[effect][i]);
-    }
-    return ret;
-}
-
-static int set_wb_mode(sensor_t *sensor, int mode)
-{
-    int ret=0;
-    if (mode < 0 || mode > NUM_WB_MODES) {
-        return -1;
-    }
-    sensor->status.wb_mode = mode;
-    SET_REG_BITS_OR_RETURN(BANK_DSP, 0XC7, 6, 1, mode?1:0);
-    if(mode) {
-        for (int i=0; i<3; i++) {
-            WRITE_REG_OR_RETURN(BANK_DSP, wb_modes_regs[0][i], wb_modes_regs[mode][i]);
-        }
-    }
-    return ret;
-}
-
-static int set_ae_level(sensor_t *sensor, int level)
-{
-    int ret=0;
-    level += 3;
-    if (level <= 0 || level > NUM_AE_LEVELS) {
-        return -1;
-    }
-    sensor->status.ae_level = level-3;
-    for (int i=0; i<3; i++) {
-        WRITE_REG_OR_RETURN(BANK_SENSOR, ae_levels_regs[0][i], ae_levels_regs[level][i]);
-    }
-    return ret;
-}
-
-static int set_quality(sensor_t *sensor, int quality)
-{
-    if(quality < 0) {
-        quality = 0;
-    } else if(quality > 63) {
-        quality = 63;
-    }
-    sensor->status.quality = quality;
-    return write_reg(sensor, BANK_DSP, QS, quality);
-}
-
-static int set_agc_gain(sensor_t *sensor, int gain)
-{
-    if(gain < 0) {
-        gain = 0;
-    } else if(gain > 30) {
-        gain = 30;
-    }
-    sensor->status.agc_gain = gain;
-    return write_reg(sensor, BANK_SENSOR, GAIN, agc_gain_tbl[gain]);
-}
-
-static int set_gainceiling_sensor(sensor_t *sensor, gainceiling_t gainceiling)
-{
-    sensor->status.gainceiling = gainceiling;
-    //return write_reg(sensor, BANK_SENSOR, COM9, COM9_AGC_SET(gainceiling));
-    return set_reg_bits(sensor, BANK_SENSOR, COM9, 5, 7, gainceiling);
-}
-
-static int set_aec_value(sensor_t *sensor, int value)
-{
-    if(value < 0) {
-        value = 0;
-    } else if(value > 1200) {
-        value = 1200;
-    }
-    sensor->status.aec_value = value;
-    return set_reg_bits(sensor, BANK_SENSOR, REG04, 0, 3, value & 0x3)
-           || write_reg(sensor, BANK_SENSOR, AEC, (value >> 2) & 0xFF)
-           || set_reg_bits(sensor, BANK_SENSOR, REG45, 0, 0x3F, value >> 10);
-}
-
-static int set_aec2(sensor_t *sensor, int enable)
-{
-    sensor->status.aec2 = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL0, 6, 1, enable?0:1);
-}
-
-static int set_colorbar(sensor_t *sensor, int enable)
-{
-    sensor->status.colorbar = enable;
-    return write_reg_bits(sensor, BANK_SENSOR, COM7, COM7_COLOR_BAR, enable?1:0);
-}
-
-static int set_agc_sensor(sensor_t *sensor, int enable)
-{
-    sensor->status.agc = enable;
-    return write_reg_bits(sensor, BANK_SENSOR, COM8, COM8_AGC_EN, enable?1:0);
-}
-
-static int set_aec_sensor(sensor_t *sensor, int enable)
-{
-    sensor->status.aec = enable;
-    return write_reg_bits(sensor, BANK_SENSOR, COM8, COM8_AEC_EN, enable?1:0);
-}
-
-static int set_hmirror_sensor(sensor_t *sensor, int enable)
-{
-    sensor->status.hmirror = enable;
-    return write_reg_bits(sensor, BANK_SENSOR, REG04, REG04_HFLIP_IMG, enable?1:0);
-}
-
-static int set_vflip_sensor(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    sensor->status.vflip = enable;
-    ret = write_reg_bits(sensor, BANK_SENSOR, REG04, REG04_VREF_EN, enable?1:0);
-    return ret & write_reg_bits(sensor, BANK_SENSOR, REG04, REG04_VFLIP_IMG, enable?1:0);
-}
-
-static int set_raw_gma_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.raw_gma = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL1, 5, 1, enable?1:0);
-}
-
-static int set_awb_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.awb = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL1, 3, 1, enable?1:0);
-}
-
-static int set_awb_gain_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.awb_gain = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL1, 2, 1, enable?1:0);
-}
-
-static int set_lenc_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.lenc = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL1, 1, 1, enable?1:0);
-}
-
-static int set_dcw_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.dcw = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL2, 5, 1, enable?1:0);
-}
-
-static int set_bpc_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.bpc = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL3, 7, 1, enable?1:0);
-}
-
-static int set_wpc_dsp(sensor_t *sensor, int enable)
-{
-    sensor->status.wpc = enable;
-    return set_reg_bits(sensor, BANK_DSP, CTRL3, 6, 1, enable?1:0);
-}
-
-//unsupported
-static int set_sharpness(sensor_t *sensor, int level)
-{
-   return -1;
-}
-
-static int set_denoise(sensor_t *sensor, int level)
-{
-   return -1;
-}
-
-static int get_reg(sensor_t *sensor, int reg, int mask)
-{
-    int ret = read_reg(sensor, (reg >> 8) & 0x01, reg & 0xFF);
-    if(ret > 0){
-        ret &= mask;
-    }
-    return ret;
-}
-
-static int set_reg(sensor_t *sensor, int reg, int mask, int value)
-{
-    int ret = 0;
-    ret = read_reg(sensor, (reg >> 8) & 0x01, reg & 0xFF);
-    if(ret < 0){
-        return ret;
-    }
-    value = (ret & ~mask) | (value & mask);
-    ret = write_reg(sensor, (reg >> 8) & 0x01, reg & 0xFF, value);
-    return ret;
-}
-
-static int set_res_raw(sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning)
-{
-    return set_window(sensor, (ov2640_sensor_mode_t)startX, offsetX, offsetY, totalX, totalY, outputX, outputY);
-}
-
-static int _set_pll(sensor_t *sensor, int bypass, int multiplier, int sys_div, int root_2x, int pre_div, int seld5, int pclk_manual, int pclk_div)
-{
-    return -1;
-}
-
-esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz);
-static int set_xclk(sensor_t *sensor, int timer, int xclk)
-{
-    int ret = 0;
-    sensor->xclk_freq_hz = xclk * 1000000U;
-    ret = xclk_timer_conf(timer, sensor->xclk_freq_hz);
-    return ret;
-}
-
-static int init_status(sensor_t *sensor){
-    sensor->status.brightness = 0;
-    sensor->status.contrast = 0;
-    sensor->status.saturation = 0;
-    sensor->status.ae_level = 0;
-    sensor->status.special_effect = 0;
-    sensor->status.wb_mode = 0;
-
-    sensor->status.agc_gain = 30;
-    int agc_gain = read_reg(sensor, BANK_SENSOR, GAIN);
-    for (int i=0; i<30; i++){
-        if(agc_gain >= agc_gain_tbl[i] && agc_gain < agc_gain_tbl[i+1]){
-            sensor->status.agc_gain = i;
-            break;
-        }
-    }
-
-    sensor->status.aec_value = ((uint16_t)get_reg_bits(sensor, BANK_SENSOR, REG45, 0, 0x3F) << 10)
-                             | ((uint16_t)read_reg(sensor, BANK_SENSOR, AEC) << 2)
-                             | get_reg_bits(sensor, BANK_SENSOR, REG04, 0, 3);//0 - 1200
-    sensor->status.quality = read_reg(sensor, BANK_DSP, QS);
-    sensor->status.gainceiling = get_reg_bits(sensor, BANK_SENSOR, COM9, 5, 7);
-
-    sensor->status.awb = get_reg_bits(sensor, BANK_DSP, CTRL1, 3, 1);
-    sensor->status.awb_gain = get_reg_bits(sensor, BANK_DSP, CTRL1, 2, 1);
-    sensor->status.aec = get_reg_bits(sensor, BANK_SENSOR, COM8, 0, 1);
-    sensor->status.aec2 = get_reg_bits(sensor, BANK_DSP, CTRL0, 6, 1);
-    sensor->status.agc = get_reg_bits(sensor, BANK_SENSOR, COM8, 2, 1);
-    sensor->status.bpc = get_reg_bits(sensor, BANK_DSP, CTRL3, 7, 1);
-    sensor->status.wpc = get_reg_bits(sensor, BANK_DSP, CTRL3, 6, 1);
-    sensor->status.raw_gma = get_reg_bits(sensor, BANK_DSP, CTRL1, 5, 1);
-    sensor->status.lenc = get_reg_bits(sensor, BANK_DSP, CTRL1, 1, 1);
-    sensor->status.hmirror = get_reg_bits(sensor, BANK_SENSOR, REG04, 7, 1);
-    sensor->status.vflip = get_reg_bits(sensor, BANK_SENSOR, REG04, 6, 1);
-    sensor->status.dcw = get_reg_bits(sensor, BANK_DSP, CTRL2, 5, 1);
-    sensor->status.colorbar = get_reg_bits(sensor, BANK_SENSOR, COM7, 1, 1);
-
-    sensor->status.sharpness = 0;//not supported
-    sensor->status.denoise = 0;
-    return 0;
-}
-
-int ov2640_init(sensor_t *sensor)
-{
-    sensor->reset = reset;
-    sensor->init_status = init_status;
-    sensor->set_pixformat = set_pixformat;
-    sensor->set_framesize = set_framesize;
-    sensor->set_contrast  = set_contrast;
-    sensor->set_brightness= set_brightness;
-    sensor->set_saturation= set_saturation;
-
-    sensor->set_quality = set_quality;
-    sensor->set_colorbar = set_colorbar;
-
-    sensor->set_gainceiling = set_gainceiling_sensor;
-    sensor->set_gain_ctrl = set_agc_sensor;
-    sensor->set_exposure_ctrl = set_aec_sensor;
-    sensor->set_hmirror = set_hmirror_sensor;
-    sensor->set_vflip = set_vflip_sensor;
-
-    sensor->set_whitebal = set_awb_dsp;
-    sensor->set_aec2 = set_aec2;
-    sensor->set_aec_value = set_aec_value;
-    sensor->set_special_effect = set_special_effect;
-    sensor->set_wb_mode = set_wb_mode;
-    sensor->set_ae_level = set_ae_level;
-
-    sensor->set_dcw = set_dcw_dsp;
-    sensor->set_bpc = set_bpc_dsp;
-    sensor->set_wpc = set_wpc_dsp;
-    sensor->set_awb_gain = set_awb_gain_dsp;
-    sensor->set_agc_gain = set_agc_gain;
-
-    sensor->set_raw_gma = set_raw_gma_dsp;
-    sensor->set_lenc = set_lenc_dsp;
-
-    //not supported
-    sensor->set_sharpness = set_sharpness;
-    sensor->set_denoise = set_denoise;
-
-    sensor->get_reg = get_reg;
-    sensor->set_reg = set_reg;
-    sensor->set_res_raw = set_res_raw;
-    sensor->set_pll = _set_pll;
-    sensor->set_xclk = set_xclk;
-    ESP_LOGD(TAG, "OV2640 Attached");
-    return 0;
-}
--- a/code/components/esp32-camera-master/sensors/ov3660.c
+++ b/code/components/esp32-camera-master/sensors/ov3660.c
--- a/code/components/esp32-camera-master/sensors/ov5640.c
+++ b/code/components/esp32-camera-master/sensors/ov5640.c
--- a/code/components/esp32-camera-master/sensors/ov7670.c
+++ b/code/components/esp32-camera-master/sensors/ov7670.c
@@ -1,439 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV7725 driver.
- *
- */
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include "sccb.h"
-#include "ov7670.h"
-#include "ov7670_regs.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include <stdio.h>
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#else
-#include "esp_log.h"
-static const char* TAG = "ov7760";
-#endif
-
-static int ov7670_clkrc = 0x01;
-
-/*
- * The default register settings, as obtained from OmniVision.  There
- * is really no making sense of most of these - lots of "reserved" values
- * and such.
- *
- * These settings give VGA YUYV.
- */
-struct regval_list {
-	uint8_t reg_num;
-	uint8_t value;
-};
-
-static struct regval_list ov7670_default_regs[] = {
-    /* Sensor automatically sets output window when resolution changes. */    
-    {TSLB, 0x04}, 
-    
-    /* Frame rate 30 fps at 12 Mhz clock */    
-	{CLKRC, 0x00},  
-	{DBLV,  0x4A},  
-
-    {COM10, COM10_VSYNC_NEG | COM10_PCLK_MASK},
-
-    /* Improve white balance */ 
-	{COM4, 0x40},  
-    
-    /* Improve color */   
-    {RSVD_B0, 0x84},  
-
-    /* Enable 50/60 Hz auto detection */
-    {COM11, COM11_EXP|COM11_HZAUTO}, 
-
-    /* Disable some delays */
-	{HSYST, 0},
-    {HSYEN, 0},   
-
-    {MVFP, MVFP_SUN}, 
-
-	/* More reserved magic, some of which tweaks white balance */
-	{AWBC1, 0x0a},		
-    {AWBC2, 0xf0},
-	{AWBC3, 0x34},		
-    {AWBC4, 0x58},
-	{AWBC5, 0x28},		
-    {AWBC6, 0x3a},
-	
-    {AWBCTR3, 0x0a},		
-    {AWBCTR2, 0x55},
-	{AWBCTR1, 0x11},		
-    {AWBCTR0, 0x9e}, 
-
-    {COM8, COM8_FAST_AUTO|COM8_STEP_UNLIMIT|COM8_AGC_EN|COM8_AEC_EN|COM8_AWB_EN},
-
-    /* End marker is FF because in ov7670 the address of GAIN 0 and default value too. */
-    {0xFF, 0xFF},  
-};
-
-static struct regval_list ov7670_fmt_yuv422[] = {
-	{ COM7,     0x0                         },  /* Selects YUV mode */
-	{ RGB444,   0                           },  /* No RGB444 please */
-	{ COM1,     0                           },  /* CCIR601 */
-	{ COM15,    COM15_R00FF                 },
-    { MVFP,     MVFP_SUN                    }, 
-	{ COM9,     0x6A                        },  /* 128x gain ceiling; 0x8 is reserved bit */
-	{ MTX1,     0x80                        },  /* "matrix coefficient 1" */
-	{ MTX2,     0x80                        }, 	/* "matrix coefficient 2" */
-	{ MTX3,     0                           },  /* vb */
-	{ MTX4,     0x22                        }, 	/* "matrix coefficient 4" */
-	{ MTX5,     0x5e                        },  /* "matrix coefficient 5" */
-	{ MTX6,     0x80                        },  /* "matrix coefficient 6" */
-	{ COM13,    COM13_UVSAT                 },
-	{ 0xff,     0xff                        },  /* END MARKER */
-};
-
-static struct regval_list ov7670_fmt_rgb565[] = {
-	{ COM7,     COM7_FMT_RGB565             },	/* Selects RGB mode */
-	{ RGB444,   0                           },	/* No RGB444 please */
-	{ COM1,     0x0                         },	/* CCIR601 */
-	{ COM15,    COM15_RGB565 |COM15_R00FF   },
-    { MVFP,     MVFP_SUN                    },   
-	{ COM9,     0x6A                        }, 	/* 128x gain ceiling; 0x8 is reserved bit */
-	{ MTX1,     0xb3                        }, 	/* "matrix coefficient 1" */
-	{ MTX2,     0xb3                        }, 	/* "matrix coefficient 2" */
-	{ MTX3,     0                           },	/* vb */
-	{ MTX4,     0x3d                        }, 	/* "matrix coefficient 4" */
-	{ MTX5,     0xa7                        }, 	/* "matrix coefficient 5" */
-	{ MTX6,     0xe4                        }, 	/* "matrix coefficient 6" */
-	{ COM13,    COM13_UVSAT                 },
-	{ 0xff,     0xff                        },  /* END MARKER */
-};
-
-
-static struct regval_list ov7670_vga[] = {
-    { COM3,                 0x00 },
-    { COM14,                0x00 },
-    { SCALING_XSC,          0x3A },
-    { SCALING_YSC,          0x35 },
-    { SCALING_DCWCTR,       0x11 },
-    { SCALING_PCLK_DIV,     0xF0 },
-    { SCALING_PCLK_DELAY,   0x02 },
-    { 0xff, 0xff },
-};
-
-static struct regval_list ov7670_qvga[] = {
-    { COM3,                 0x04 },
-    { COM14,                0x19 },
-    { SCALING_XSC,          0x3A },
-    { SCALING_YSC,          0x35 },
-    { SCALING_DCWCTR,       0x11 },
-    { SCALING_PCLK_DIV,     0xF1 },
-    { SCALING_PCLK_DELAY,   0x02 },
-    { 0xff, 0xff },
-};
-
-static struct regval_list ov7670_qqvga[] = {
-	{ COM3,                 0x04 }, //DCW enable	
-	{ COM14,                0x1a }, //pixel clock divided by 4, manual scaling enable, DCW and PCLK controlled by register	
-	{ SCALING_XSC,          0x3a },	
-	{ SCALING_YSC,          0x35 },
-	{ SCALING_DCWCTR,       0x22 }, //downsample by 4	
-	{ SCALING_PCLK_DIV,     0xf2 }, //pixel clock divided by 4	
-	{ SCALING_PCLK_DELAY,   0x02 },
-    { 0xff, 0xff },
-};
-
-/*
- * Write a list of register settings; ff/ff stops the process.
- */
-static int ov7670_write_array(sensor_t *sensor, struct regval_list *vals)
-{
-int ret = 0;
-	
-	while ( (vals->reg_num != 0xff || vals->value != 0xff) && (ret == 0) ) {
-        ret = SCCB_Write(sensor->slv_addr, vals->reg_num, vals->value);
-
-	    ESP_LOGD(TAG, "reset reg %02X, W(%02X) R(%02X)", vals->reg_num, 
-                        vals->value, SCCB_Read(sensor->slv_addr, vals->reg_num) );
-		
-		vals++;
-	}
-
-    return ret;
-}
-
-/*
- * Calculate the frame control registers.
- */
-static int ov7670_frame_control(sensor_t *sensor, int hstart, int hstop, int vstart, int vstop)
-{
-struct regval_list frame[7];
-
-    frame[0].reg_num = HSTART;
-    frame[0].value = (hstart >> 3);
-
-    frame[1].reg_num = HSTOP;
-    frame[1].value = (hstop >> 3);
-
-    frame[2].reg_num = HREF;
-    frame[2].value = (((hstop & 0x07) << 3) | (hstart & 0x07));
-    
-    frame[3].reg_num = VSTART;
-    frame[3].value = (vstart >> 2);
-    
-    frame[4].reg_num = VSTOP;
-    frame[4].value = (vstop >> 2);
-
-    frame[5].reg_num = VREF;
-    frame[5].value = (((vstop & 0x02) << 2) | (vstart & 0x02));
-
-    /* End mark */
-    frame[5].reg_num = 0xFF;
-    frame[5].value = 0xFF;
-
-    return ov7670_write_array(sensor, frame);
-}
-
-static int reset(sensor_t *sensor)
-{
-    int ret;
-
-    // Reset all registers
-    SCCB_Write(sensor->slv_addr, COM7, COM7_RESET);
-
-    // Delay 10 ms
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-
-    ret = ov7670_write_array(sensor, ov7670_default_regs);
-
-    // Delay
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    return ret;
-}
-
-static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
-{
-int ret;
-
-    switch (pixformat) {
-        case PIXFORMAT_RGB565:
-        case PIXFORMAT_RGB888:
-            ret = ov7670_write_array(sensor, ov7670_fmt_rgb565);
-        break;
- 
-        case PIXFORMAT_YUV422:
-        case PIXFORMAT_GRAYSCALE:
-	    default:
-            ret = ov7670_write_array(sensor, ov7670_fmt_yuv422);
-        break;
-    }
-
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    /*
-	 * If we're running RGB565, we must rewrite clkrc after setting
-	 * the other parameters or the image looks poor.  If we're *not*
-	 * doing RGB565, we must not rewrite clkrc or the image looks
-	 * *really* poor.
-	 *
-	 * (Update) Now that we retain clkrc state, we should be able
-	 * to write it unconditionally, and that will make the frame
-	 * rate persistent too.
-	 */
-    if (pixformat == PIXFORMAT_RGB565) {
-        ret = SCCB_Write(sensor->slv_addr, CLKRC, ov7670_clkrc); 
-    }
-
-    return ret;
-}
-
-static int set_framesize(sensor_t *sensor, framesize_t framesize)
-{
-   int ret;
-
-    // store clkrc before changing window settings...
-    ov7670_clkrc =  SCCB_Read(sensor->slv_addr, CLKRC);
-     
-	switch (framesize){
-        case FRAMESIZE_VGA:
-            if( (ret = ov7670_write_array(sensor, ov7670_vga)) == 0 ) {
-                /* These values from Omnivision */
-                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
-            }
-        break;
-	    case FRAMESIZE_QVGA:
-            if( (ret = ov7670_write_array(sensor, ov7670_qvga)) == 0 ) {
-                /* These values from Omnivision */
-                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
-            }
-        break;
-	    case FRAMESIZE_QQVGA:
-            if( (ret = ov7670_write_array(sensor, ov7670_qqvga)) == 0 ) {
-                /* These values from Omnivision */
-                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
-            }
-        break; 
-
-        default:
-            ret = -1;   
-    }
-
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    if (ret == 0) {
-        sensor->status.framesize = framesize;
-    }
-
-	return ret;
-}
-
-static int set_colorbar(sensor_t *sensor, int enable)
-{
-    uint8_t ret = 0;
-    // Read register scaling_xsc
-    uint8_t reg = SCCB_Read(sensor->slv_addr, SCALING_XSC);
-
-    // Pattern to set color bar bit[0]=0 in every case
-    reg = SCALING_XSC_CBAR(reg);
-
-    // Write pattern to SCALING_XSC
-    ret = SCCB_Write(sensor->slv_addr, SCALING_XSC, reg);
-
-    // Read register scaling_ysc
-    reg = SCCB_Read(sensor->slv_addr, SCALING_YSC);
-
-    // Pattern to set color bar bit[0]=0 in every case
-    reg = SCALING_YSC_CBAR(reg, enable);
-
-    // Write pattern to SCALING_YSC
-    ret = ret | SCCB_Write(sensor->slv_addr, SCALING_YSC, reg);
-
-    // return 0 or 0xFF
-    return ret;
-}
-
-static int set_whitebal(sensor_t *sensor, int enable)
-{
-    // Read register COM8
-    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
-
-    // Set white bal on/off
-    reg = COM8_SET_AWB(reg, enable);
-
-    // Write back register COM8
-    return SCCB_Write(sensor->slv_addr, COM8, reg);
-}
-
-static int set_gain_ctrl(sensor_t *sensor, int enable)
-{
-    // Read register COM8
-    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
-
-    // Set white bal on/off
-    reg = COM8_SET_AGC(reg, enable);
-
-    // Write back register COM8
-    return SCCB_Write(sensor->slv_addr, COM8, reg);
-}
-
-static int set_exposure_ctrl(sensor_t *sensor, int enable)
-{
-    // Read register COM8
-    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
-
-    // Set white bal on/off
-    reg = COM8_SET_AEC(reg, enable);
-
-    // Write back register COM8
-    return SCCB_Write(sensor->slv_addr, COM8, reg);
-}
-
-static int set_hmirror(sensor_t *sensor, int enable)
-{
-    // Read register MVFP
-    uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
-
-    // Set mirror on/off
-    reg = MVFP_SET_MIRROR(reg, enable);
-
-    // Write back register MVFP
-    return SCCB_Write(sensor->slv_addr, MVFP, reg);
-}
-
-static int set_vflip(sensor_t *sensor, int enable)
-{
-    // Read register MVFP
-    uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
-
-    // Set mirror on/off
-    reg = MVFP_SET_FLIP(reg, enable);
-
-    // Write back register MVFP
-    return SCCB_Write(sensor->slv_addr, MVFP, reg);
-}
-
-static int init_status(sensor_t *sensor)
-{
-    sensor->status.awb = 0;
-    sensor->status.aec = 0;
-    sensor->status.agc = 0;
-    sensor->status.hmirror = 0;
-    sensor->status.vflip = 0;
-    sensor->status.colorbar = 0;
-    return 0;
-}
-
-static int set_dummy(sensor_t *sensor, int val){ return -1; }
-static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val){ return -1; }
-
-int ov7670_init(sensor_t *sensor)
-{
-    // Set function pointers
-    sensor->reset = reset;
-    sensor->init_status = init_status;
-    sensor->set_pixformat = set_pixformat;
-    sensor->set_framesize = set_framesize;
-    sensor->set_colorbar = set_colorbar;
-    sensor->set_whitebal = set_whitebal;
-    sensor->set_gain_ctrl = set_gain_ctrl;
-    sensor->set_exposure_ctrl = set_exposure_ctrl;
-    sensor->set_hmirror = set_hmirror;
-    sensor->set_vflip = set_vflip;
-
-    //not supported
-    sensor->set_brightness= set_dummy;
-    sensor->set_saturation= set_dummy;
-    sensor->set_quality = set_dummy;
-    sensor->set_gainceiling = set_gainceiling_dummy;
-    sensor->set_aec2 = set_dummy;
-    sensor->set_aec_value = set_dummy;
-    sensor->set_special_effect = set_dummy;
-    sensor->set_wb_mode = set_dummy;
-    sensor->set_ae_level = set_dummy;
-    sensor->set_dcw = set_dummy;
-    sensor->set_bpc = set_dummy;
-    sensor->set_wpc = set_dummy;
-    sensor->set_awb_gain = set_dummy;
-    sensor->set_agc_gain = set_dummy;
-    sensor->set_raw_gma = set_dummy;
-    sensor->set_lenc = set_dummy;
-    sensor->set_sharpness = set_dummy;
-    sensor->set_denoise = set_dummy;
-
-    // Retrieve sensor's signature
-    sensor->id.MIDH = SCCB_Read(sensor->slv_addr, REG_MIDH);
-    sensor->id.MIDL = SCCB_Read(sensor->slv_addr, REG_MIDL);
-    sensor->id.PID = SCCB_Read(sensor->slv_addr, REG_PID);
-    sensor->id.VER = SCCB_Read(sensor->slv_addr, REG_VER);
-    
-    ESP_LOGD(TAG, "OV7670 Attached");
-    
-    return 0;
-}
--- a/code/components/esp32-camera-master/sensors/ov7725.c
+++ b/code/components/esp32-camera-master/sensors/ov7725.c
@@ -1,557 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV7725 driver.
- *
- */
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "sccb.h"
-#include "ov7725.h"
-#include "ov7725_regs.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
-#include "esp32-hal-log.h"
-#else
-#include "esp_log.h"
-static const char* TAG = "ov7725";
-#endif
-
-
-static const uint8_t default_regs[][2] = {
-    {COM3,          COM3_SWAP_YUV},
-    {COM7,          COM7_RES_QVGA | COM7_FMT_YUV},
-
-    {COM4,          0x01 | 0x00}, /* bypass PLL (0x00:off, 0x40:4x, 0x80:6x, 0xC0:8x) */
-    {CLKRC,         0x80 | 0x03}, /* Res/Bypass pre-scalar (0x40:bypass, 0x00-0x3F:prescaler PCLK=XCLK/(prescaler + 1)/2 ) */
-
-    // QVGA Window Size
-    {HSTART,        0x3F},
-    {HSIZE,         0x50},
-    {VSTART,        0x03},
-    {VSIZE,         0x78},
-    {HREF,          0x00},
-
-    // Scale down to QVGA Resolution
-    {HOUTSIZE,      0x50},
-    {VOUTSIZE,      0x78},
-    {EXHCH,         0x00},
-
-    {COM12,         0x03},
-    {TGT_B,         0x7F},
-    {FIXGAIN,       0x09},
-    {AWB_CTRL0,     0xE0},
-    {DSP_CTRL1,     0xFF},
-
-    {DSP_CTRL2,     DSP_CTRL2_VDCW_EN | DSP_CTRL2_HDCW_EN | DSP_CTRL2_HZOOM_EN | DSP_CTRL2_VZOOM_EN},
-
-    {DSP_CTRL3,     0x00},
-    {DSP_CTRL4,     0x00},
-    {DSPAUTO,       0xFF},
-
-    {COM8,          0xF0},
-    {COM6,          0xC5},
-    {COM9,          0x11},
-    {COM10,         COM10_VSYNC_NEG | COM10_PCLK_MASK}, //Invert VSYNC and MASK PCLK
-    {BDBASE,        0x7F},
-    {DBSTEP,        0x03},
-    {AEW,           0x96},
-    {AEB,           0x64},
-    {VPT,           0xA1},
-    {EXHCL,         0x00},
-    {AWB_CTRL3,     0xAA},
-    {COM8,          0xFF},
-
-    //Gamma
-    {GAM1,          0x0C},
-    {GAM2,          0x16},
-    {GAM3,          0x2A},
-    {GAM4,          0x4E},
-    {GAM5,          0x61},
-    {GAM6,          0x6F},
-    {GAM7,          0x7B},
-    {GAM8,          0x86},
-    {GAM9,          0x8E},
-    {GAM10,         0x97},
-    {GAM11,         0xA4},
-    {GAM12,         0xAF},
-    {GAM13,         0xC5},
-    {GAM14,         0xD7},
-    {GAM15,         0xE8},
-
-    {SLOP,          0x20},
-    {EDGE1,         0x05},
-    {EDGE2,         0x03},
-    {EDGE3,         0x00},
-    {DNSOFF,        0x01},
-
-    {MTX1,          0xB0},
-    {MTX2,          0x9D},
-    {MTX3,          0x13},
-    {MTX4,          0x16},
-    {MTX5,          0x7B},
-    {MTX6,          0x91},
-    {MTX_CTRL,      0x1E},
-
-    {BRIGHTNESS,    0x08},
-    {CONTRAST,      0x30},
-    {UVADJ0,        0x81},
-    {SDE,           (SDE_CONT_BRIGHT_EN | SDE_SATURATION_EN)},
-
-    // For 30 fps/60Hz
-    {DM_LNL,        0x00},
-    {DM_LNH,        0x00},
-    {BDBASE,        0x7F},
-    {DBSTEP,        0x03},
-
-    // Lens Correction, should be tuned with real camera module
-    {LC_RADI,       0x10},
-    {LC_COEF,       0x10},
-    {LC_COEFB,      0x14},
-    {LC_COEFR,      0x17},
-    {LC_CTR,        0x05},
-    {COM5,          0xF5}, //0x65
-
-    {0x00,          0x00},
-};
-
-static int get_reg(sensor_t *sensor, int reg, int mask)
-{
-    int ret = SCCB_Read(sensor->slv_addr, reg & 0xFF);
-    if(ret > 0){
-        ret &= mask;
-    }
-    return ret;
-}
-
-static int set_reg(sensor_t *sensor, int reg, int mask, int value)
-{
-    int ret = 0;
-    ret = SCCB_Read(sensor->slv_addr, reg & 0xFF);
-    if(ret < 0){
-        return ret;
-    }
-    value = (ret & ~mask) | (value & mask);
-    ret = SCCB_Write(sensor->slv_addr, reg & 0xFF, value);
-    return ret;
-}
-
-static int set_reg_bits(sensor_t *sensor, uint8_t reg, uint8_t offset, uint8_t length, uint8_t value)
-{
-    int ret = 0;
-    ret = SCCB_Read(sensor->slv_addr, reg);
-    if(ret < 0){
-        return ret;
-    }
-    uint8_t mask = ((1 << length) - 1) << offset;
-    value = (ret & ~mask) | ((value << offset) & mask);
-    ret = SCCB_Write(sensor->slv_addr, reg & 0xFF, value);
-    return ret;
-}
-
-static int get_reg_bits(sensor_t *sensor, uint8_t reg, uint8_t offset, uint8_t length)
-{
-    int ret = 0;
-    ret = SCCB_Read(sensor->slv_addr, reg);
-    if(ret < 0){
-        return ret;
-    }
-    uint8_t mask = ((1 << length) - 1) << offset;
-    return (ret & mask) >> offset;
-}
-
-
-static int reset(sensor_t *sensor)
-{
-    int i=0;
-    const uint8_t (*regs)[2];
-
-    // Reset all registers
-    SCCB_Write(sensor->slv_addr, COM7, COM7_RESET);
-
-    // Delay 10 ms
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-
-    // Write default regsiters
-    for (i=0, regs = default_regs; regs[i][0]; i++) {
-        SCCB_Write(sensor->slv_addr, regs[i][0], regs[i][1]);
-    }
-
-    // Delay
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    return 0;
-}
-
-
-static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
-{
-    int ret=0;
-    sensor->pixformat = pixformat;
-    // Read register COM7
-    uint8_t reg = SCCB_Read(sensor->slv_addr, COM7);
-
-    switch (pixformat) {
-    case PIXFORMAT_RGB565:
-        reg =  COM7_SET_RGB(reg, COM7_FMT_RGB565);
-        break;
-    case PIXFORMAT_YUV422:
-    case PIXFORMAT_GRAYSCALE:
-        reg =  COM7_SET_FMT(reg, COM7_FMT_YUV);
-        break;
-    default:
-        return -1;
-    }
-
-    // Write back register COM7
-    ret = SCCB_Write(sensor->slv_addr, COM7, reg);
-
-    // Delay
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    return ret;
-}
-
-static int set_framesize(sensor_t *sensor, framesize_t framesize)
-{
-    int ret=0;
-    if (framesize > FRAMESIZE_VGA) {
-        return -1;
-    }
-    uint16_t w = resolution[framesize].width;
-    uint16_t h = resolution[framesize].height;
-    uint8_t reg = SCCB_Read(sensor->slv_addr, COM7);
-
-    sensor->status.framesize = framesize;
-
-    // Write MSBs
-    ret |= SCCB_Write(sensor->slv_addr, HOUTSIZE, w>>2);
-    ret |= SCCB_Write(sensor->slv_addr, VOUTSIZE, h>>1);
-
-    ret |= SCCB_Write(sensor->slv_addr, HSIZE, w>>2);
-    ret |= SCCB_Write(sensor->slv_addr, VSIZE, h>>1);
-
-    // Write LSBs
-    ret |= SCCB_Write(sensor->slv_addr, HREF, ((w&0x3) | ((h&0x1) << 2)));
-
-    if (framesize < FRAMESIZE_VGA) {
-        // Enable auto-scaling/zooming factors
-        ret |= SCCB_Write(sensor->slv_addr, DSPAUTO, 0xFF);
-
-        ret |= SCCB_Write(sensor->slv_addr, HSTART, 0x3F);
-        ret |= SCCB_Write(sensor->slv_addr, VSTART, 0x03);
-
-        ret |= SCCB_Write(sensor->slv_addr, COM7, reg | COM7_RES_QVGA);
-
-        ret |= SCCB_Write(sensor->slv_addr, CLKRC, 0x80 | 0x01);
-
-    } else {
-        // Disable auto-scaling/zooming factors
-        ret |= SCCB_Write(sensor->slv_addr, DSPAUTO, 0xF3);
-
-        // Clear auto-scaling/zooming factors
-        ret |= SCCB_Write(sensor->slv_addr, SCAL0, 0x00);
-        ret |= SCCB_Write(sensor->slv_addr, SCAL1, 0x00);
-        ret |= SCCB_Write(sensor->slv_addr, SCAL2, 0x00);
-
-        ret |= SCCB_Write(sensor->slv_addr, HSTART, 0x23);
-        ret |= SCCB_Write(sensor->slv_addr, VSTART, 0x07);
-
-        ret |= SCCB_Write(sensor->slv_addr, COM7, reg & ~COM7_RES_QVGA);
-
-        ret |= SCCB_Write(sensor->slv_addr, CLKRC, 0x80 | 0x03);
-    }
-
-    // Delay
-    vTaskDelay(30 / portTICK_PERIOD_MS);
-
-    return ret;
-}
-
-static int set_colorbar(sensor_t *sensor, int enable)
-{
-    int ret=0;
-    uint8_t reg;
-    sensor->status.colorbar = enable;
-
-    // Read reg COM3
-    reg = SCCB_Read(sensor->slv_addr, COM3);
-    // Enable colorbar test pattern output
-    reg = COM3_SET_CBAR(reg, enable);
-    // Write back COM3
-    ret |= SCCB_Write(sensor->slv_addr, COM3, reg);
-
-    // Read reg DSP_CTRL3
-    reg = SCCB_Read(sensor->slv_addr, DSP_CTRL3);
-    // Enable DSP colorbar output
-    reg = DSP_CTRL3_SET_CBAR(reg, enable);
-    // Write back DSP_CTRL3
-    ret |= SCCB_Write(sensor->slv_addr, DSP_CTRL3, reg);
-
-    return ret;
-}
-
-static int set_whitebal(sensor_t *sensor, int enable)
-{
-    if(set_reg_bits(sensor, COM8, 1, 1, enable) >= 0){
-        sensor->status.awb = !!enable;
-    }
-    return sensor->status.awb;
-}
-
-static int set_gain_ctrl(sensor_t *sensor, int enable)
-{
-    if(set_reg_bits(sensor, COM8, 2, 1, enable) >= 0){
-        sensor->status.agc = !!enable;
-    }
-    return sensor->status.agc;
-}
-
-static int set_exposure_ctrl(sensor_t *sensor, int enable)
-{
-    if(set_reg_bits(sensor, COM8, 0, 1, enable) >= 0){
-        sensor->status.aec = !!enable;
-    }
-    return sensor->status.aec;
-}
-
-static int set_hmirror(sensor_t *sensor, int enable)
-{
-    if(set_reg_bits(sensor, COM3, 6, 1, enable) >= 0){
-        sensor->status.hmirror = !!enable;
-    }
-    return sensor->status.hmirror;
-}
-
-static int set_vflip(sensor_t *sensor, int enable)
-{
-    if(set_reg_bits(sensor, COM3, 7, 1, enable) >= 0){
-        sensor->status.vflip = !!enable;
-    }
-    return sensor->status.vflip;
-}
-
-static int set_dcw_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, 0x65, 2, 1, !enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set dcw to: %d", enable);
-        sensor->status.dcw = enable;
-    }
-    return ret;
-}
-
-static int set_aec2(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, COM8, 7, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set aec2 to: %d", enable);
-        sensor->status.aec2 = enable;
-    }
-    return ret;
-}
-
-static int set_bpc_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, 0x64, 1, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set bpc to: %d", enable);
-        sensor->status.bpc = enable;
-    }
-    return ret;
-}
-
-static int set_wpc_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, 0x64, 0, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set wpc to: %d", enable);
-        sensor->status.wpc = enable;
-    }
-    return ret;
-}
-
-static int set_raw_gma_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, 0x64, 2, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set raw_gma to: %d", enable);
-        sensor->status.raw_gma = enable;
-    }
-    return ret;
-}
-
-static int set_lenc_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, LC_CTR, 0, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set lenc to: %d", enable);
-        sensor->status.lenc = enable;
-    }
-    return ret;
-}
-
-//real gain
-static int set_agc_gain(sensor_t *sensor, int gain)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, COM9, 4, 3, gain % 5);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set gain to: %d", gain);
-        sensor->status.agc_gain = gain;
-    }
-    return ret;
-}
-
-static int set_aec_value(sensor_t *sensor, int value)
-{
-    int ret = 0;
-    ret =  SCCB_Write(sensor->slv_addr, AEC, value & 0xff) | SCCB_Write(sensor->slv_addr, AECH, value >> 8);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set aec_value to: %d", value);
-        sensor->status.aec_value = value;
-    }
-    return ret;
-}
-
-static int set_awb_gain_dsp(sensor_t *sensor, int enable)
-{
-    int ret = 0;
-    ret = set_reg_bits(sensor, 0x63, 7, 1, enable);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set awb_gain to: %d", enable);
-        sensor->status.awb_gain = enable;
-    }
-    return ret;
-}
-
-static int set_brightness(sensor_t *sensor, int level)
-{
-    int ret = 0;
-    ret = SCCB_Write(sensor->slv_addr, 0x9B, level);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set brightness to: %d", level);
-        sensor->status.brightness = level;
-    }
-    return ret;
-}
-
-static int set_contrast(sensor_t *sensor, int level)
-{
-    int ret = 0;
-    ret = SCCB_Write(sensor->slv_addr, 0x9C, level);
-    if (ret == 0) {
-        ESP_LOGD(TAG, "Set contrast to: %d", level);
-        sensor->status.contrast = level;
-    }
-    return ret;
-}
-
-static int init_status(sensor_t *sensor)
-{
-    sensor->status.brightness = SCCB_Read(sensor->slv_addr, 0x9B);
-    sensor->status.contrast = SCCB_Read(sensor->slv_addr, 0x9C);
-    sensor->status.saturation = 0;
-    sensor->status.ae_level = 0;
-    sensor->status.special_effect = get_reg_bits(sensor, 0x64, 5, 1);
-    sensor->status.wb_mode = get_reg_bits(sensor, 0x6B, 7, 1);
-    sensor->status.agc_gain = get_reg_bits(sensor, COM9, 4, 3);
-    sensor->status.aec_value = SCCB_Read(sensor->slv_addr, AEC) | (SCCB_Read(sensor->slv_addr, AECH) << 8);
-    sensor->status.gainceiling = SCCB_Read(sensor->slv_addr, 0x00);
-    sensor->status.awb = get_reg_bits(sensor, COM8, 1, 1);
-    sensor->status.awb_gain = get_reg_bits(sensor, 0x63, 7, 1);
-    sensor->status.aec = get_reg_bits(sensor, COM8, 0, 1);
-    sensor->status.aec2 = get_reg_bits(sensor, COM8, 7, 1);
-    sensor->status.agc = get_reg_bits(sensor, COM8, 2, 1);
-    sensor->status.bpc = get_reg_bits(sensor, 0x64, 1, 1);
-    sensor->status.wpc = get_reg_bits(sensor, 0x64, 0, 1);
-    sensor->status.raw_gma = get_reg_bits(sensor, 0x64, 2, 1);
-    sensor->status.lenc = get_reg_bits(sensor, LC_CTR, 0, 1);
-    sensor->status.hmirror = get_reg_bits(sensor, COM3, 6, 1);
-    sensor->status.vflip = get_reg_bits(sensor, COM3, 7, 1);
-    sensor->status.dcw = get_reg_bits(sensor, 0x65, 2, 1);
-    sensor->status.colorbar = get_reg_bits(sensor, COM3, 0, 1);
-    sensor->status.sharpness = get_reg_bits(sensor, EDGE0, 0, 5);
-    sensor->status.denoise = SCCB_Read(sensor->slv_addr, 0x8E);
-    return 0;
-}
-
-static int set_dummy(sensor_t *sensor, int val){ return -1; }
-static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val){ return -1; }
-static int set_res_raw(sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning){return -1;}
-static int _set_pll(sensor_t *sensor, int bypass, int multiplier, int sys_div, int root_2x, int pre_div, int seld5, int pclk_manual, int pclk_div){return -1;}
-
-esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz);
-static int set_xclk(sensor_t *sensor, int timer, int xclk)
-{
-    int ret = 0;
-    sensor->xclk_freq_hz = xclk * 1000000U;
-    ret = xclk_timer_conf(timer, sensor->xclk_freq_hz);
-    return ret;
-}
-
-int ov7725_init(sensor_t *sensor)
-{
-    // Set function pointers
-    sensor->reset = reset;
-    sensor->init_status = init_status;
-    sensor->set_pixformat = set_pixformat;
-    sensor->set_framesize = set_framesize;
-    sensor->set_colorbar = set_colorbar;
-    sensor->set_whitebal = set_whitebal;
-    sensor->set_gain_ctrl = set_gain_ctrl;
-    sensor->set_exposure_ctrl = set_exposure_ctrl;
-    sensor->set_hmirror = set_hmirror;
-    sensor->set_vflip = set_vflip;
-
-    sensor->set_brightness = set_brightness;
-    sensor->set_contrast = set_contrast;
-    sensor->set_aec2 = set_aec2;
-    sensor->set_aec_value = set_aec_value;
-    sensor->set_awb_gain = set_awb_gain_dsp;
-    sensor->set_agc_gain = set_agc_gain;
-    sensor->set_dcw = set_dcw_dsp;
-    sensor->set_bpc = set_bpc_dsp;
-    sensor->set_wpc = set_wpc_dsp;
-    sensor->set_raw_gma = set_raw_gma_dsp;
-    sensor->set_lenc = set_lenc_dsp;
-
-    //not supported
-    sensor->set_saturation= set_dummy;
-    sensor->set_sharpness = set_dummy;
-    sensor->set_denoise = set_dummy;
-    sensor->set_quality = set_dummy;
-    sensor->set_special_effect = set_dummy;
-    sensor->set_wb_mode = set_dummy;
-    sensor->set_ae_level = set_dummy;
-    sensor->set_gainceiling = set_gainceiling_dummy;
-
-
-    sensor->get_reg = get_reg;
-    sensor->set_reg = set_reg;
-    sensor->set_res_raw = set_res_raw;
-    sensor->set_pll = _set_pll;
-    sensor->set_xclk = set_xclk;
-    
-    // Retrieve sensor's signature
-    sensor->id.MIDH = SCCB_Read(sensor->slv_addr, REG_MIDH);
-    sensor->id.MIDL = SCCB_Read(sensor->slv_addr, REG_MIDL);
-    sensor->id.PID = SCCB_Read(sensor->slv_addr, REG_PID);
-    sensor->id.VER = SCCB_Read(sensor->slv_addr, REG_VER);
-    
-    ESP_LOGD(TAG, "OV7725 Attached");
-
-    return 0;
-}
--- a/code/components/esp32-camera-master/sensors/private_include/nt99141.h
+++ b/code/components/esp32-camera-master/sensors/private_include/nt99141.h
@@ -1,16 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * NT99141 driver.
- *
- */
-#ifndef __NT99141_H__
-#define __NT99141_H__
-
-#include "sensor.h"
-
-int NT99141_init(sensor_t *sensor);
-
-#endif // __NT99141_H__
--- a/code/components/esp32-camera-master/sensors/private_include/nt99141_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/nt99141_regs.h
@@ -1,211 +0,0 @@
-/*
- * NT99141 register definitions.
- */
-#ifndef __NT99141_REG_REGS_H__
-#define __NT99141_REG_REGS_H__
-
-/* system control registers */
-#define SYSTEM_CTROL0   0x3021  // Bit[7]: Software reset 
-                                // Bit[6]: Software power down 
-                                // Bit[5]: Reserved 
-                                // Bit[4]: SRB clock SYNC enable 
-                                // Bit[3]: Isolation suspend select 
-                                // Bit[2:0]: Not used
-
-/* output format control registers */
-#define FORMAT_CTRL     0x501F // Format select
-                                // Bit[2:0]:
-                                //  000: YUV422						
-                                //  001: RGB
-                                //  010: Dither
-                                //  011: RAW after DPC
-                                //  101: RAW after CIP
-
-/* format control registers */
-#define FORMAT_CTRL00   0x4300
-
-/* frame control registers */
-#define FRAME_CTRL01    0x4201  // Control Passed Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // Bit[3:0]: Frame ON number
-#define FRAME_CTRL02    0x4202  // Control Masked Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // BIT[3:0]: Frame OFF number
-
-/* ISP top control registers */
-#define PRE_ISP_TEST_SETTING_1  0x3025  // Bit[7]: Test enable
-                                        //         0: Test disable
-                                        //         1: Color bar enable
-                                        // Bit[6]: Rolling
-                                        // Bit[5]: Transparent
-                                        // Bit[4]: Square black and white
-                                        // Bit[3:2]: Color bar style
-                                        //         00: Standard 8 color bar
-                                        //         01: Gradual change at vertical mode 1
-                                        //         10: Gradual change at horizontal
-                                        //         11: Gradual change at vertical mode 2
-                                        // Bit[1:0]: Test select
-                                        //         00: Color bar
-                                        //         01: Random data
-                                        //         10: Square data
-                                        //         11: Black image
-
-//exposure = {0x3500[3:0], 0x3501[7:0], 0x3502[7:0]} / 16 × tROW
-
-/* AEC/AGC control functions */
-#define AEC_PK_MANUAL   0x3201  // AEC Manual Mode Control
-                                // Bit[7:6]: Reserved
-                                // Bit[5]: Gain delay option
-                                //         Valid when 0x3503[4]=1’b0
-                                //         0: Delay one frame latch
-                                //         1: One frame latch
-                                // Bit[4:2]: Reserved
-                                // Bit[1]: AGC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-                                // Bit[0]: AEC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-
-//gain = {0x350A[1:0], 0x350B[7:0]} / 16
-
-/* mirror and flip registers */
-#define TIMING_TC_REG20 0x3022  // Timing Control Register
-                                // Bit[2:1]: Vertical flip enable
-                                //         00: Normal
-                                //         11: Vertical flip
-                                // Bit[0]: Vertical binning enable
-#define TIMING_TC_REG21 0x3022  // Timing Control Register
-                                // Bit[5]: Compression Enable
-                                // Bit[2:1]: Horizontal mirror enable
-                                //         00: Normal
-                                //         11: Horizontal mirror
-                                // Bit[0]: Horizontal binning enable
-
-#define CLOCK_POL_CONTROL 0x3024// Bit[5]: PCLK polarity 0: active low
-                                //          1: active high
-                                // Bit[3]: Gate PCLK under VSYNC
-                                // Bit[2]: Gate PCLK under HREF
-                                // Bit[1]: HREF polarity
-                                //          0: active low
-                                //          1: active high
-                                // Bit[0] VSYNC polarity
-                                //          0: active low
-                                //          1: active high
-#define DRIVE_CAPABILITY 0x306a // Bit[7:6]:
-                                //          00: 1x
-                                //          01: 2x
-                                //          10: 3x
-                                //          11: 4x
-
-
-#define X_ADDR_ST_H     0x3800 //Bit[3:0]: X address start[11:8]
-#define X_ADDR_ST_L     0x3801 //Bit[7:0]: X address start[7:0]
-#define Y_ADDR_ST_H     0x3802 //Bit[2:0]: Y address start[10:8]
-#define Y_ADDR_ST_L     0x3803 //Bit[7:0]: Y address start[7:0]
-#define X_ADDR_END_H    0x3804 //Bit[3:0]: X address end[11:8]
-#define X_ADDR_END_L    0x3805 //Bit[7:0]:
-#define Y_ADDR_END_H    0x3806 //Bit[2:0]: Y address end[10:8]
-#define Y_ADDR_END_L    0x3807 //Bit[7:0]:
-// Size after scaling
-#define X_OUTPUT_SIZE_H 0x3808 //Bit[3:0]: DVP output horizontal width[11:8]
-#define X_OUTPUT_SIZE_L 0x3809 //Bit[7:0]:
-#define Y_OUTPUT_SIZE_H 0x380a //Bit[2:0]: DVP output vertical height[10:8]
-#define Y_OUTPUT_SIZE_L 0x380b //Bit[7:0]:
-#define X_TOTAL_SIZE_H  0x380c //Bit[3:0]: Total horizontal size[11:8]
-#define X_TOTAL_SIZE_L  0x380d //Bit[7:0]:
-#define Y_TOTAL_SIZE_H  0x380e //Bit[7:0]: Total vertical size[15:8]
-#define Y_TOTAL_SIZE_L  0x380f //Bit[7:0]:
-#define X_OFFSET_H      0x3810 //Bit[3:0]: ISP horizontal offset[11:8]
-#define X_OFFSET_L      0x3811 //Bit[7:0]:
-#define Y_OFFSET_H      0x3812 //Bit[2:0]: ISP vertical offset[10:8]
-#define Y_OFFSET_L      0x3813 //Bit[7:0]:
-#define X_INCREMENT     0x3814 //Bit[7:4]: Horizontal odd subsample increment
-                               //Bit[3:0]: Horizontal even subsample increment
-#define Y_INCREMENT     0x3815 //Bit[7:4]: Vertical odd subsample increment
-                               //Bit[3:0]: Vertical even subsample increment
-// Size before scaling
-//#define X_INPUT_SIZE    (X_ADDR_END - X_ADDR_ST + 1 - (2 * X_OFFSET))
-//#define Y_INPUT_SIZE    (Y_ADDR_END - Y_ADDR_ST + 1 - (2 * Y_OFFSET))
-
-#define ISP_CONTROL_01   0x3021 // Bit[5]: Scale enable
-                                //          0: Disable
-                                //          1: Enable
-
-#define SCALE_CTRL_1     0x5601 // Bit[6:4]: HDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-                                // Bit[2:0]: VDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-
-#define SCALE_CTRL_2     0x5602 // X_SCALE High Bits
-#define SCALE_CTRL_3     0x5603 // X_SCALE Low Bits
-#define SCALE_CTRL_4     0x5604 // Y_SCALE High Bits
-#define SCALE_CTRL_5     0x5605 // Y_SCALE Low Bits
-#define SCALE_CTRL_6     0x5606 // Bit[3:0]: V Offset
-
-#define PCLK_RATIO       0x3824 // Bit[4:0]: PCLK ratio manual
-#define VFIFO_CTRL0C     0x460C // Bit[1]: PCLK manual enable
-                                //          0: Auto
-                                //          1: Manual by PCLK_RATIO
-
-#define VFIFO_X_SIZE_H   0x4602
-#define VFIFO_X_SIZE_L   0x4603
-#define VFIFO_Y_SIZE_H   0x4604
-#define VFIFO_Y_SIZE_L   0x4605
-
-#define SC_PLLS_CTRL0    0x303a // Bit[7]: PLLS bypass
-#define SC_PLLS_CTRL1    0x303b // Bit[4:0]: PLLS multiplier
-#define SC_PLLS_CTRL2    0x303c // Bit[6:4]: PLLS charge pump control
-                                // Bit[3:0]: PLLS system divider
-#define SC_PLLS_CTRL3    0x303d // Bit[5:4]: PLLS pre-divider
-                                //          00: 1
-                                //          01: 1.5
-                                //          10: 2
-                                //          11: 3
-                                // Bit[2]: PLLS root-divider - 1
-                                // Bit[1:0]: PLLS seld5
-                                //          00: 1
-                                //          01: 1
-                                //          10: 2
-                                //          11: 2.5
-
-#define COMPRESSION_CTRL00 0x4400 //
-#define COMPRESSION_CTRL01 0x4401 //
-#define COMPRESSION_CTRL02 0x4402 //
-#define COMPRESSION_CTRL03 0x4403 //
-#define COMPRESSION_CTRL04 0x4404 //
-#define COMPRESSION_CTRL05 0x4405 //
-#define COMPRESSION_CTRL06 0x4406 //
-#define COMPRESSION_CTRL07 0x3401 // Bit[5:0]: QS
-#define COMPRESSION_ISI_CTRL 0x4408 //
-#define COMPRESSION_CTRL09 0x4409 //
-#define COMPRESSION_CTRL0a 0x440a //
-#define COMPRESSION_CTRL0b 0x440b //
-#define COMPRESSION_CTRL0c 0x440c //
-#define COMPRESSION_CTRL0d 0x440d //
-#define COMPRESSION_CTRL0E 0x440e //
-
-/**
- * @brief register value
- */
-#define TEST_COLOR_BAR  0x02    /* Enable Color Bar roling Test */
-
-#define AEC_PK_MANUAL_AGC_MANUALEN  0x02    /* Enable AGC Manual enable */
-#define AEC_PK_MANUAL_AEC_MANUALEN  0x01    /* Enable AEC Manual enable */
-
-#define TIMING_TC_REG20_VFLIP   0x01 /* Vertical flip enable */
-#define TIMING_TC_REG21_HMIRROR 0x02 /* Horizontal mirror enable */
-
-#endif // __NT99141_REG_REGS_H__
--- a/code/components/esp32-camera-master/sensors/private_include/nt99141_settings.h
+++ b/code/components/esp32-camera-master/sensors/private_include/nt99141_settings.h
@@ -1,825 +0,0 @@
-#ifndef _NT99141_SETTINGS_H_
-#define _NT99141_SETTINGS_H_
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_attr.h"
-#include "nt99141_regs.h"
-
-static const ratio_settings_t ratio_table[] = {
-    //  mw,   mh,  sx,  sy,   ex,   ey, ox, oy,   tx,   ty
-    { 1280, 720,   0,   4, 1283, 723, 0, 4, 1660, 963 }, 
-
-};
-
-#define REG_DLY 0xffff
-#define REGLIST_TAIL 0x0000
-
-static const DRAM_ATTR uint16_t sensor_default_regs[][2] = {
- //initial
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x3109, 0x04},
-{0x3040, 0x04},
-{0x3041, 0x02},
-{0x3042, 0xFF},
-{0x3043, 0x08},
-{0x3052, 0xE0},
-{0x305F, 0x33},
-{0x3100, 0x07},
-{0x3106, 0x03},
-{0x3105, 0x01},
-{0x3108, 0x05},
-{0x3110, 0x22},
-{0x3111, 0x57},
-{0x3112, 0x22},
-{0x3113, 0x55},
-{0x3114, 0x05},
-{0x3135, 0x00},
-{0x32F0, 0x01},
-{0x3290, 0x01},
-{0x3291, 0x80},
-{0x3296, 0x01},
-{0x3297, 0x73},
-{0x3250, 0x80},
-{0x3251, 0x03},
-{0x3252, 0xFF},
-{0x3253, 0x00},
-{0x3254, 0x03},
-{0x3255, 0xFF},
-{0x3256, 0x00},
-{0x3257, 0x50},
-{0x3270, 0x00},
-{0x3271, 0x0C},
-{0x3272, 0x18},
-{0x3273, 0x32},
-{0x3274, 0x44},
-{0x3275, 0x54},
-{0x3276, 0x70},
-{0x3277, 0x88},
-{0x3278, 0x9D},
-{0x3279, 0xB0},
-{0x327A, 0xCF},
-{0x327B, 0xE2},
-{0x327C, 0xEF},
-{0x327D, 0xF7},
-{0x327E, 0xFF},
-{0x3302, 0x00},
-{0x3303, 0x40},
-{0x3304, 0x00},
-{0x3305, 0x96},
-{0x3306, 0x00},
-{0x3307, 0x29},
-{0x3308, 0x07},
-{0x3309, 0xBA},
-{0x330A, 0x06},
-{0x330B, 0xF5},
-{0x330C, 0x01},
-{0x330D, 0x51},
-{0x330E, 0x01},
-{0x330F, 0x30},
-{0x3310, 0x07},
-{0x3311, 0x16},
-{0x3312, 0x07},
-{0x3313, 0xBA},
-{0x3326, 0x02},
-{0x32F6, 0x0F},
-{0x32F9, 0x42},
-{0x32FA, 0x24},
-{0x3325, 0x4A},
-{0x3330, 0x00},
-{0x3331, 0x0A},
-{0x3332, 0xFF},
-{0x3338, 0x30},
-{0x3339, 0x84},
-{0x333A, 0x48},
-{0x333F, 0x07},
-{0x3360, 0x10},
-{0x3361, 0x18},
-{0x3362, 0x1f},
-{0x3363, 0x37},
-{0x3364, 0x80},
-{0x3365, 0x80},
-{0x3366, 0x68},
-{0x3367, 0x60},
-{0x3368, 0x30},
-{0x3369, 0x28},
-{0x336A, 0x20},
-{0x336B, 0x10},
-{0x336C, 0x00},
-{0x336D, 0x20},
-{0x336E, 0x1C},
-{0x336F, 0x18},
-{0x3370, 0x10},
-{0x3371, 0x38},
-{0x3372, 0x3C},
-{0x3373, 0x3F},
-{0x3374, 0x3F},
-{0x338A, 0x34},
-{0x338B, 0x7F},
-{0x338C, 0x10},
-{0x338D, 0x23},
-{0x338E, 0x7F},
-{0x338F, 0x14},
-{0x3375, 0x08},
-{0x3376, 0x0C},
-{0x3377, 0x18},
-{0x3378, 0x20},
-{0x3012, 0x02},
-{0x3013, 0xD0},
-{0x3025, 0x02}, //colorbar
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_jpeg[][2] = {
-    {0x32F0, 0x70}, // YUV422
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_raw[][2] = {
-    {0x32F0, 0x50}, // RAW
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_grayscale[][2] = {
-    {0x32F1, 0x01},
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_yuv422[][2] = {
-    {0x32F0, 0x00}, // YUV422
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_rgb565[][2] = {
-    {0x32F0, 0x01}, // RGB
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint8_t sensor_saturation_levels[9][1] = {
-    {0x60},//-4
-    {0x68},//-3
-    {0x70},//-2
-    {0x78},//-1
-    {0x80},//0
-    {0x88},//+1
-    {0x90},//+2
-    {0x98},//+3
-    {0xA0},//+4
-};
-
-static const DRAM_ATTR uint8_t sensor_special_effects[7][4] = {
-    {0x00, 0x80, 0x80, 0x01},//Normal
-    {0x03, 0x80, 0x80, 0x01},//Negative
-    {0x01, 0x80, 0x80, 0x01},//Grayscale
-    {0x05, 0x2A, 0xF0, 0x01},//Red Tint
-    {0x05, 0x60, 0x20, 0x01},//Green Tint
-    {0x05, 0xF0, 0x80, 0x01},//Blue Tint
-    {0x02, 0x80, 0x80, 0x01},//Sepia
-	
-};
-
-// AE LEVEL
-static const DRAM_ATTR uint16_t sensor_ae_level[][2] = {
-
-// 1. [AE_Target : 0x24]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x29 },
- {0x32B9, 0x1F },
- {0x32BC, 0x24 },
- {0x32BD, 0x27 },
- {0x32BE, 0x21 },
-//------------------------------------------------------------------------
-// 2. [AE_Target : 0x28]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x2D },
- {0x32B9, 0x23 },
- {0x32BC, 0x28 },
- {0x32BD, 0x2B },
- {0x32BE, 0x25 },
-//------------------------------------------------------------------------
-// 3. [AE_Target : 0x2C]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x32 },
- {0x32B9, 0x26 },
- {0x32BC, 0x2C },
- {0x32BD, 0x2F },
- {0x32BE, 0x29 },
-//------------------------------------------------------------------------
-// 4, [AE_Target : 0x30]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x36 },
- {0x32B9, 0x2A },
- {0x32BC, 0x30 },
- {0x32BD, 0x33 },
- {0x32BE, 0x2D },
-//------------------------------------------------------------------------
-// 5. [AE_Target : 0x34]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x3B },
- {0x32B9, 0x2D },
- {0x32BC, 0x34 },
- {0x32BD, 0x38 },
- {0x32BE, 0x30 },
-//------------------------------------------------------------------------
-// 6. [AE_Target : 0x38]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x3F },
- {0x32B9, 0x31 },
- {0x32BC, 0x38 },
- {0x32BD, 0x3C },
- {0x32BE, 0x34 },
-//------------------------------------------------------------------------
-// 7. [AE_Target : 0x3D]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x44 },
- {0x32B9, 0x34 },
- {0x32BC, 0x3C },
- {0x32BD, 0x40 },
- {0x32BE, 0x38 },
-//------------------------------------------------------------------------
-// 8. [AE_Target : 0x40]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x48 },
- {0x32B9, 0x38 },
- {0x32BC, 0x40 },
- {0x32BD, 0x44 },
- {0x32BE, 0x3C },
-//------------------------------------------------------------------------
-// 9. [AE_Target : 0x44]
-// Set_Device_Format = FORMAT_16_8
-// SET_Device_Addr = 0x54
- {0x32B8, 0x4D },
- {0x32B9, 0x3B },
- {0x32BC, 0x44 },
- {0x32BD, 0x49 },
- {0x32BE, 0x3F },
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_HD[][2] = {
-//[JPEG_1280x720_8.18_8.18_Fps]
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x3C}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x5E}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x24}, 
-{0x3002, 0x00}, 
-{0x3003, 0x04}, 
-{0x3004, 0x00}, 
-{0x3005, 0x04}, 
-{0x3006, 0x05}, 
-{0x3007, 0x03}, 
-{0x3008, 0x02}, 
-{0x3009, 0xD3}, 
-{0x300A, 0x06}, 
-{0x300B, 0x7C}, 
-{0x300C, 0x02}, 
-{0x300D, 0xE0}, 
-{0x300E, 0x05}, 
-{0x300F, 0x00}, 
-{0x3010, 0x02}, 
-{0x3011, 0xD0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x3F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = {
-//[JPEG_640x480_10.14_10.14_Fps]
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x4B}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x62}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x32E0, 0x02}, 
-{0x32E1, 0x80}, 
-{0x32E2, 0x01}, 
-{0x32E3, 0xE0}, 
-{0x32E4, 0x00}, 
-{0x32E5, 0x80}, 
-{0x32E6, 0x00}, 
-{0x32E7, 0x80}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x24}, 
-{0x3002, 0x00}, 
-{0x3003, 0xA4}, 
-{0x3004, 0x00}, 
-{0x3005, 0x04}, 
-{0x3006, 0x04}, 
-{0x3007, 0x63}, 
-{0x3008, 0x02}, 
-{0x3009, 0xD3}, 
-{0x300A, 0x05}, 
-{0x300B, 0x3C}, 
-{0x300C, 0x02}, 
-{0x300D, 0xE0}, 
-{0x300E, 0x03}, 
-{0x300F, 0xC0}, 
-{0x3010, 0x02}, 
-{0x3011, 0xD0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x7F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_QVGA[][2] = {
-//[JPEG_320x240_10.14_10.14_Fps] 
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x4B}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x62}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x32E0, 0x01}, 
-{0x32E1, 0x40}, 
-{0x32E2, 0x00}, 
-{0x32E3, 0xF0}, 
-{0x32E4, 0x02}, 
-{0x32E5, 0x02}, 
-{0x32E6, 0x02}, 
-{0x32E7, 0x03}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x24}, 
-{0x3002, 0x00}, 
-{0x3003, 0xA4}, 
-{0x3004, 0x00}, 
-{0x3005, 0x04}, 
-{0x3006, 0x04}, 
-{0x3007, 0x63}, 
-{0x3008, 0x02}, 
-{0x3009, 0xD3}, 
-{0x300A, 0x05}, 
-{0x300B, 0x3C}, 
-{0x300C, 0x02}, 
-{0x300D, 0xE0}, 
-{0x300E, 0x03}, 
-{0x300F, 0xC0}, 
-{0x3010, 0x02}, 
-{0x3011, 0xD0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x7F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_VGA_xyskip[][2] = {
-// [JPEG_640x360_20.00_25.01_Fps_XY_Skip]
-// Set_Device_Format = FORMAT_16_8 
-// SET_Device_Addr = 0x54 
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60 },
-{0x320A, 0xB2 },
-{0x32C0, 0x64 },
-{0x32C1, 0x64 },
-{0x32C2, 0x64 },
-{0x32C3, 0x00 },
-{0x32C4, 0x20 },
-{0x32C5, 0x20 },
-{0x32C6, 0x20 },
-{0x32C7, 0x00 },
-{0x32C8, 0x62 },
-{0x32C9, 0x64 },
-{0x32CA, 0x84 },
-{0x32CB, 0x84 },
-{0x32CC, 0x84 },
-{0x32CD, 0x84 },
-{0x32DB, 0x68 },
-{0x32F0, 0x70 },
-{0x3400, 0x08 },
-{0x3400, 0x00 },
-{0x3401, 0x4E },
-{0x3404, 0x00 },
-{0x3405, 0x00 },
-{0x3410, 0x00 },
-{0x3200, 0x3E },
-{0x3201, 0x0F },
-{0x3028, 0x0F },
-{0x3029, 0x00 },
-{0x302A, 0x08 },
-{0x3022, 0x24 },
-{0x3023, 0x6C },
-{0x3002, 0x00 },
-{0x3003, 0x04 },
-{0x3004, 0x00 },
-{0x3005, 0x04 },
-{0x3006, 0x05 },
-{0x3007, 0x03 },
-{0x3008, 0x02 },
-{0x3009, 0xD3 },
-{0x300A, 0x03 },
-{0x300B, 0xFC },
-{0x300C, 0x01 },
-{0x300D, 0x88 },
-{0x300E, 0x02 },
-{0x300F, 0x80 },
-{0x3010, 0x01 },
-{0x3011, 0x68 },
-{0x32B8, 0x3F },
-{0x32B9, 0x31 },
-{0x32BB, 0x87 },
-{0x32BC, 0x38 },
-{0x32BD, 0x3C },
-{0x32BE, 0x34 },
-{0x3201, 0x3F },
-{0x3025, 0x00 }, //normal
-{0x3021, 0x06 },
-{0x3400, 0x01 },
-{0x3060, 0x01 },
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_VGA_xskip[][2] = {
-//[JPEG_640x480_Xskip_13.32_13.32_Fps]
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x62}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x68}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x32E0, 0x02}, 
-{0x32E1, 0x80}, 
-{0x32E2, 0x01}, 
-{0x32E3, 0xE0}, 
-{0x32E4, 0x00}, 
-{0x32E5, 0x00}, 
-{0x32E6, 0x00}, 
-{0x32E7, 0x80}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x2C}, 
-{0x3002, 0x00}, 
-{0x3003, 0x04}, 
-{0x3004, 0x00}, 
-{0x3005, 0x04}, 
-{0x3006, 0x05}, 
-{0x3007, 0x03}, 
-{0x3008, 0x02}, 
-{0x3009, 0xD3}, 
-{0x300A, 0x03}, 
-{0x300B, 0xFC}, 
-{0x300C, 0x02}, 
-{0x300D, 0xE0}, 
-{0x300E, 0x02}, 
-{0x300F, 0x80}, 
-{0x3010, 0x02}, 
-{0x3011, 0xD0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x7F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_QVGA_xskip[][2] = {
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-//[JPEG_320x240_Xskip_13.32_13.32_Fps]
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x62}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x68}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x32E0, 0x01}, 
-{0x32E1, 0x40}, 
-{0x32E2, 0x00}, 
-{0x32E3, 0xF0}, 
-{0x32E4, 0x01}, 
-{0x32E5, 0x01}, 
-{0x32E6, 0x02}, 
-{0x32E7, 0x03}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x2C}, 
-{0x3002, 0x00}, 
-{0x3003, 0x04}, 
-{0x3004, 0x00}, 
-{0x3005, 0x04}, 
-{0x3006, 0x05}, 
-{0x3007, 0x03}, 
-{0x3008, 0x02}, 
-{0x3009, 0xD3}, 
-{0x300A, 0x03}, 
-{0x300B, 0xFC}, 
-{0x300C, 0x02}, 
-{0x300D, 0xE0}, 
-{0x300E, 0x02}, 
-{0x300F, 0x80}, 
-{0x3010, 0x02}, 
-{0x3011, 0xD0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x7F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01},
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-
-static const DRAM_ATTR uint16_t sensor_framesize_VGA_crop[][2] = {
-//[JPEG_640x480_Crop_19.77_19.77_Fps]
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x62}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x68}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x24}, 
-{0x3002, 0x01}, 
-{0x3003, 0x44}, 
-{0x3004, 0x00}, 
-{0x3005, 0x7C}, 
-{0x3006, 0x03}, 
-{0x3007, 0xC3}, 
-{0x3008, 0x02}, 
-{0x3009, 0x5B}, 
-{0x300A, 0x03}, 
-{0x300B, 0xFC}, 
-{0x300C, 0x01}, 
-{0x300D, 0xF0}, 
-{0x300E, 0x02}, 
-{0x300F, 0x80}, 
-{0x3010, 0x01}, 
-{0x3011, 0xE0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x3F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_framesize_QVGA_crop[][2] = {
-//[JPEG_320x240_Crop_19.77_19.77_Fps]
-{0x3021, 0x00},
-{REG_DLY, 100}, // delay 100ms
-{0x32BF, 0x60}, 
-{0x32C0, 0x5A}, 
-{0x32C1, 0x5A}, 
-{0x32C2, 0x5A}, 
-{0x32C3, 0x00}, 
-{0x32C4, 0x20}, 
-{0x32C5, 0x20}, 
-{0x32C6, 0x20}, 
-{0x32C7, 0x00}, 
-{0x32C8, 0x62}, 
-{0x32C9, 0x5A}, 
-{0x32CA, 0x7A}, 
-{0x32CB, 0x7A}, 
-{0x32CC, 0x7A}, 
-{0x32CD, 0x7A}, 
-{0x32DB, 0x68}, 
-{0x32F0, 0x70}, 
-{0x3400, 0x08}, 
-{0x3400, 0x00}, 
-{0x3401, 0x4E}, 
-{0x3404, 0x00}, 
-{0x3405, 0x00}, 
-{0x3410, 0x00}, 
-{0x32E0, 0x01}, 
-{0x32E1, 0x40}, 
-{0x32E2, 0x00}, 
-{0x32E3, 0xF0}, 
-{0x32E4, 0x01}, 
-{0x32E5, 0x01}, 
-{0x32E6, 0x01}, 
-{0x32E7, 0x02}, 
-{0x3200, 0x3E}, 
-{0x3201, 0x0F}, 
-{0x3028, 0x0F}, 
-{0x3029, 0x00}, 
-{0x302A, 0x08}, 
-{0x3022, 0x24}, 
-{0x3023, 0x24}, 
-{0x3002, 0x01}, 
-{0x3003, 0x44}, 
-{0x3004, 0x00}, 
-{0x3005, 0x7C}, 
-{0x3006, 0x03}, 
-{0x3007, 0xC3}, 
-{0x3008, 0x02}, 
-{0x3009, 0x5B}, 
-{0x300A, 0x03}, 
-{0x300B, 0xFC}, 
-{0x300C, 0x01}, 
-{0x300D, 0xF0}, 
-{0x300E, 0x02}, 
-{0x300F, 0x80}, 
-{0x3010, 0x01}, 
-{0x3011, 0xE0}, 
-{0x32B8, 0x3F}, 
-{0x32B9, 0x31}, 
-{0x32BB, 0x87}, 
-{0x32BC, 0x38}, 
-{0x32BD, 0x3C}, 
-{0x32BE, 0x34}, 
-{0x3201, 0x7F}, 
-{0x3021, 0x06},
-{0x3025, 0x00}, //normal 
-{0x3400, 0x01}, 
-{0x3060, 0x01}, 
-{REGLIST_TAIL, 0x00}, // tail
-};
-
-#endif
-
-
--- a/code/components/esp32-camera-master/sensors/private_include/ov2640.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov2640.h
@@ -1,13 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV2640 driver.
- *
- */
-#ifndef __OV2640_H__
-#define __OV2640_H__
-#include "sensor.h"
-int ov2640_init(sensor_t *sensor);
-#endif // __OV2640_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov2640_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov2640_regs.h
@@ -1,216 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV2640 register definitions.
- */
-#ifndef __REG_REGS_H__
-#define __REG_REGS_H__
-/* DSP register bank FF=0x00*/
-#define R_BYPASS            0x05
-#define QS                  0x44
-#define CTRLI               0x50
-#define HSIZE               0x51
-#define VSIZE               0x52
-#define XOFFL               0x53
-#define YOFFL               0x54
-#define VHYX                0x55
-#define DPRP                0x56
-#define TEST                0x57
-#define ZMOW                0x5A
-#define ZMOH                0x5B
-#define ZMHH                0x5C
-#define BPADDR              0x7C
-#define BPDATA              0x7D
-#define CTRL2               0x86
-#define CTRL3               0x87
-#define SIZEL               0x8C
-#define HSIZE8              0xC0
-#define VSIZE8              0xC1
-#define CTRL0               0xC2
-#define CTRL1               0xC3
-#define R_DVP_SP            0xD3
-#define IMAGE_MODE          0xDA
-#define RESET               0xE0
-#define MS_SP               0xF0
-#define SS_ID               0xF7
-#define SS_CTRL             0xF7
-#define MC_BIST             0xF9
-#define MC_AL               0xFA
-#define MC_AH               0xFB
-#define MC_D                0xFC
-#define P_CMD               0xFD
-#define P_STATUS            0xFE
-#define BANK_SEL            0xFF
-
-#define CTRLI_LP_DP         0x80
-#define CTRLI_ROUND         0x40
-
-#define CTRL0_AEC_EN        0x80
-#define CTRL0_AEC_SEL       0x40
-#define CTRL0_STAT_SEL      0x20
-#define CTRL0_VFIRST        0x10
-#define CTRL0_YUV422        0x08
-#define CTRL0_YUV_EN        0x04
-#define CTRL0_RGB_EN        0x02
-#define CTRL0_RAW_EN        0x01
-
-#define CTRL2_DCW_EN        0x20
-#define CTRL2_SDE_EN        0x10
-#define CTRL2_UV_ADJ_EN     0x08
-#define CTRL2_UV_AVG_EN     0x04
-#define CTRL2_CMX_EN        0x01
-
-#define CTRL3_BPC_EN        0x80
-#define CTRL3_WPC_EN        0x40
-
-#define R_DVP_SP_AUTO_MODE  0x80
-
-#define R_BYPASS_DSP_EN         0x00
-#define R_BYPASS_DSP_BYPAS      0x01
-
-#define IMAGE_MODE_Y8_DVP_EN    0x40
-#define IMAGE_MODE_JPEG_EN      0x10
-#define IMAGE_MODE_YUV422       0x00
-#define IMAGE_MODE_RAW10        0x04
-#define IMAGE_MODE_RGB565       0x08
-#define IMAGE_MODE_HREF_VSYNC   0x02
-#define IMAGE_MODE_LBYTE_FIRST  0x01
-
-#define RESET_MICROC            0x40
-#define RESET_SCCB              0x20
-#define RESET_JPEG              0x10
-#define RESET_DVP               0x04
-#define RESET_IPU               0x02
-#define RESET_CIF               0x01
-
-#define MC_BIST_RESET           0x80
-#define MC_BIST_BOOT_ROM_SEL    0x40
-#define MC_BIST_12KB_SEL        0x20
-#define MC_BIST_12KB_MASK       0x30
-#define MC_BIST_512KB_SEL       0x08
-#define MC_BIST_512KB_MASK      0x0C
-#define MC_BIST_BUSY_BIT_R      0x02
-#define MC_BIST_MC_RES_ONE_SH_W 0x02
-#define MC_BIST_LAUNCH          0x01
-
-
-typedef enum {
-    BANK_DSP, BANK_SENSOR, BANK_MAX
-} ov2640_bank_t;
-
-/* Sensor register bank FF=0x01*/
-#define GAIN                0x00
-#define COM1                0x03
-#define REG04               0x04
-#define REG08               0x08
-#define COM2                0x09
-#define REG_PID             0x0A
-#define REG_VER             0x0B
-#define COM3                0x0C
-#define COM4                0x0D
-#define AEC                 0x10
-#define CLKRC               0x11
-#define COM7                0x12
-#define COM8                0x13
-#define COM9                0x14 /* AGC gain ceiling */
-#define COM10               0x15
-#define HSTART              0x17
-#define HSTOP               0x18
-#define VSTART              0x19
-#define VSTOP               0x1A
-#define MIDH                0x1C
-#define MIDL                0x1D
-#define AEW                 0x24
-#define AEB                 0x25
-#define VV                  0x26
-#define REG2A               0x2A
-#define FRARL               0x2B
-#define ADDVSL              0x2D
-#define ADDVSH              0x2E
-#define YAVG                0x2F
-#define HSDY                0x30
-#define HEDY                0x31
-#define REG32               0x32
-#define ARCOM2              0x34
-#define REG45               0x45
-#define FLL                 0x46
-#define FLH                 0x47
-#define COM19               0x48
-#define ZOOMS               0x49
-#define COM22               0x4B
-#define COM25               0x4E
-#define BD50                0x4F
-#define BD60                0x50
-#define REG5D               0x5D
-#define REG5E               0x5E
-#define REG5F               0x5F
-#define REG60               0x60
-#define HISTO_LOW           0x61
-#define HISTO_HIGH          0x62
-
-#define REG04_DEFAULT       0x28
-#define REG04_HFLIP_IMG     0x80
-#define REG04_VFLIP_IMG     0x40
-#define REG04_VREF_EN       0x10
-#define REG04_HREF_EN       0x08
-#define REG04_SET(x)        (REG04_DEFAULT|x)
-
-#define COM2_STDBY          0x10
-#define COM2_OUT_DRIVE_1x   0x00
-#define COM2_OUT_DRIVE_2x   0x01
-#define COM2_OUT_DRIVE_3x   0x02
-#define COM2_OUT_DRIVE_4x   0x03
-
-#define COM3_DEFAULT        0x38
-#define COM3_BAND_50Hz      0x04
-#define COM3_BAND_60Hz      0x00
-#define COM3_BAND_AUTO      0x02
-#define COM3_BAND_SET(x)    (COM3_DEFAULT|x)
-
-#define COM7_SRST           0x80
-#define COM7_RES_UXGA       0x00 /* UXGA */
-#define COM7_RES_SVGA       0x40 /* SVGA */
-#define COM7_RES_CIF        0x20 /* CIF  */
-#define COM7_ZOOM_EN        0x04 /* Enable Zoom */
-#define COM7_COLOR_BAR      0x02 /* Enable Color Bar Test */
-
-#define COM8_DEFAULT        0xC0
-#define COM8_BNDF_EN        0x20 /* Enable Banding filter */
-#define COM8_AGC_EN         0x04 /* AGC Auto/Manual control selection */
-#define COM8_AEC_EN         0x01 /* Auto/Manual Exposure control */
-#define COM8_SET(x)         (COM8_DEFAULT|x)
-
-#define COM9_DEFAULT        0x08
-#define COM9_AGC_GAIN_2x    0x00 /* AGC:    2x */
-#define COM9_AGC_GAIN_4x    0x01 /* AGC:    4x */
-#define COM9_AGC_GAIN_8x    0x02 /* AGC:    8x */
-#define COM9_AGC_GAIN_16x   0x03 /* AGC:   16x */
-#define COM9_AGC_GAIN_32x   0x04 /* AGC:   32x */
-#define COM9_AGC_GAIN_64x   0x05 /* AGC:   64x */
-#define COM9_AGC_GAIN_128x  0x06 /* AGC:  128x */
-#define COM9_AGC_SET(x)     (COM9_DEFAULT|(x<<5))
-
-#define COM10_HREF_EN       0x80 /* HSYNC changes to HREF */
-#define COM10_HSYNC_EN      0x40 /* HREF changes to HSYNC */
-#define COM10_PCLK_FREE     0x20 /* PCLK output option: free running PCLK */
-#define COM10_PCLK_EDGE     0x10 /* Data is updated at the rising edge of PCLK */
-#define COM10_HREF_NEG      0x08 /* HREF negative */
-#define COM10_VSYNC_NEG     0x02 /* VSYNC negative */
-#define COM10_HSYNC_NEG     0x01 /* HSYNC negative */
-
-#define CTRL1_AWB           0x08 /* Enable AWB */
-
-#define VV_AGC_TH_SET(h,l)  ((h<<4)|(l&0x0F))
-
-#define REG32_UXGA          0x36
-#define REG32_SVGA          0x09
-#define REG32_CIF           0x89
-
-#define CLKRC_2X            0x80
-#define CLKRC_2X_UXGA       (0x01 | CLKRC_2X)
-#define CLKRC_2X_SVGA       CLKRC_2X
-#define CLKRC_2X_CIF        CLKRC_2X
-
-#endif //__REG_REGS_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov2640_settings.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov2640_settings.h
@@ -1,485 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _OV2640_SETTINGS_H_
-#define _OV2640_SETTINGS_H_
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_attr.h"
-#include "ov2640_regs.h"
-
-typedef enum {
-    OV2640_MODE_UXGA, OV2640_MODE_SVGA, OV2640_MODE_CIF, OV2640_MODE_MAX
-} ov2640_sensor_mode_t;
-
-typedef struct {
-        union {
-                struct {
-                        uint8_t pclk_div:7;
-                        uint8_t pclk_auto:1;
-                };
-                uint8_t pclk;
-        };
-        union {
-                struct {
-                        uint8_t clk_div:6;
-                        uint8_t reserved:1;
-                        uint8_t clk_2x:1;
-                };
-                uint8_t clk;
-        };
-} ov2640_clk_t;
-
-typedef struct {
-        uint16_t offset_x;
-        uint16_t offset_y;
-        uint16_t max_x;
-        uint16_t max_y;
-} ov2640_ratio_settings_t;
-
-static const DRAM_ATTR ov2640_ratio_settings_t ratio_table[] = {
-    // ox,  oy,   mx,   my
-    {   0,   0, 1600, 1200 }, //4x3
-    {   8,  72, 1584, 1056 }, //3x2
-    {   0, 100, 1600, 1000 }, //16x10
-    {   0, 120, 1600,  960 }, //5x3
-    {   0, 150, 1600,  900 }, //16x9
-    {   2, 258, 1596,  684 }, //21x9
-    {  50,   0, 1500, 1200 }, //5x4
-    { 200,   0, 1200, 1200 }, //1x1
-    { 462,   0,  676, 1200 }  //9x16
-};
-
-// 30fps@24MHz
-const DRAM_ATTR uint8_t ov2640_settings_cif[][2] = {
-    {BANK_SEL, BANK_DSP},
-    {0x2c, 0xff},
-    {0x2e, 0xdf},
-    {BANK_SEL, BANK_SENSOR},
-    {0x3c, 0x32},
-    {CLKRC, 0x01},
-    {COM2, COM2_OUT_DRIVE_3x},
-    {REG04, REG04_DEFAULT},
-    {COM8, COM8_DEFAULT | COM8_BNDF_EN | COM8_AGC_EN | COM8_AEC_EN},
-    {COM9, COM9_AGC_SET(COM9_AGC_GAIN_8x)},
-    {0x2c, 0x0c},
-    {0x33, 0x78},
-    {0x3a, 0x33},
-    {0x3b, 0xfB},
-    {0x3e, 0x00},
-    {0x43, 0x11},
-    {0x16, 0x10},
-    {0x39, 0x92},
-    {0x35, 0xda},
-    {0x22, 0x1a},
-    {0x37, 0xc3},
-    {0x23, 0x00},
-    {ARCOM2, 0xc0},
-    {0x06, 0x88},
-    {0x07, 0xc0},
-    {COM4, 0x87},
-    {0x0e, 0x41},
-    {0x4c, 0x00},
-    {0x4a, 0x81},
-    {0x21, 0x99},
-    {AEW, 0x40},
-    {AEB, 0x38},
-    {VV, VV_AGC_TH_SET(8,2)},
-    {0x5c, 0x00},
-    {0x63, 0x00},
-    {HISTO_LOW, 0x70},
-    {HISTO_HIGH, 0x80},
-    {0x7c, 0x05},
-    {0x20, 0x80},
-    {0x28, 0x30},
-    {0x6c, 0x00},
-    {0x6d, 0x80},
-    {0x6e, 0x00},
-    {0x70, 0x02},
-    {0x71, 0x94},
-    {0x73, 0xc1},
-    {0x3d, 0x34},
-    {0x5a, 0x57},
-    {BD50, 0xbb},
-    {BD60, 0x9c},
-    {COM7, COM7_RES_CIF},
-    {HSTART, 0x11},
-    {HSTOP, 0x43},
-    {VSTART, 0x00},
-    {VSTOP, 0x25},
-    {REG32, 0x89},
-    {0x37, 0xc0},
-    {BD50, 0xca},
-    {BD60, 0xa8},
-    {0x6d, 0x00},
-    {0x3d, 0x38},
-    {BANK_SEL, BANK_DSP},
-    {0xe5, 0x7f},
-    {MC_BIST, MC_BIST_RESET | MC_BIST_BOOT_ROM_SEL},
-    {0x41, 0x24},
-    {RESET, RESET_JPEG | RESET_DVP},
-    {0x76, 0xff},
-    {0x33, 0xa0},
-    {0x42, 0x20},
-    {0x43, 0x18},
-    {0x4c, 0x00},
-    {CTRL3, CTRL3_WPC_EN | 0x10 },
-    {0x88, 0x3f},
-    {0xd7, 0x03},
-    {0xd9, 0x10},
-    {R_DVP_SP, R_DVP_SP_AUTO_MODE | 0x02},
-    {0xc8, 0x08},
-    {0xc9, 0x80},
-    {BPADDR, 0x00},
-    {BPDATA, 0x00},
-    {BPADDR, 0x03},
-    {BPDATA, 0x48},
-    {BPDATA, 0x48},
-    {BPADDR, 0x08},
-    {BPDATA, 0x20},
-    {BPDATA, 0x10},
-    {BPDATA, 0x0e},
-    {0x90, 0x00},
-    {0x91, 0x0e},
-    {0x91, 0x1a},
-    {0x91, 0x31},
-    {0x91, 0x5a},
-    {0x91, 0x69},
-    {0x91, 0x75},
-    {0x91, 0x7e},
-    {0x91, 0x88},
-    {0x91, 0x8f},
-    {0x91, 0x96},
-    {0x91, 0xa3},
-    {0x91, 0xaf},
-    {0x91, 0xc4},
-    {0x91, 0xd7},
-    {0x91, 0xe8},
-    {0x91, 0x20},
-    {0x92, 0x00},
-    {0x93, 0x06},
-    {0x93, 0xe3},
-    {0x93, 0x05},
-    {0x93, 0x05},
-    {0x93, 0x00},
-    {0x93, 0x04},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x93, 0x00},
-    {0x96, 0x00},
-    {0x97, 0x08},
-    {0x97, 0x19},
-    {0x97, 0x02},
-    {0x97, 0x0c},
-    {0x97, 0x24},
-    {0x97, 0x30},
-    {0x97, 0x28},
-    {0x97, 0x26},
-    {0x97, 0x02},
-    {0x97, 0x98},
-    {0x97, 0x80},
-    {0x97, 0x00},
-    {0x97, 0x00},
-    {0xa4, 0x00},
-    {0xa8, 0x00},
-    {0xc5, 0x11},
-    {0xc6, 0x51},
-    {0xbf, 0x80},
-    {0xc7, 0x10},
-    {0xb6, 0x66},
-    {0xb8, 0xA5},
-    {0xb7, 0x64},
-    {0xb9, 0x7C},
-    {0xb3, 0xaf},
-    {0xb4, 0x97},
-    {0xb5, 0xFF},
-    {0xb0, 0xC5},
-    {0xb1, 0x94},
-    {0xb2, 0x0f},
-    {0xc4, 0x5c},
-    {CTRL1, 0xfd},
-    {0x7f, 0x00},
-    {0xe5, 0x1f},
-    {0xe1, 0x67},
-    {0xdd, 0x7f},
-    {IMAGE_MODE, 0x00},
-    {RESET, 0x00},
-    {R_BYPASS, R_BYPASS_DSP_EN},
-    {0, 0}
-};
-
-const DRAM_ATTR uint8_t ov2640_settings_to_cif[][2] = {
-    {BANK_SEL, BANK_SENSOR},
-    {COM7, COM7_RES_CIF},
-
-    //Set the sensor output window
-    {COM1, 0x0A},
-    {REG32, REG32_CIF},
-    {HSTART, 0x11},
-    {HSTOP, 0x43},
-    {VSTART, 0x00},
-    {VSTOP, 0x25},
-
-    //{CLKRC, 0x00},
-    {BD50, 0xca},
-    {BD60, 0xa8},
-    {0x5a, 0x23},
-    {0x6d, 0x00},
-    {0x3d, 0x38},
-    {0x39, 0x92},
-    {0x35, 0xda},
-    {0x22, 0x1a},
-    {0x37, 0xc3},
-    {0x23, 0x00},
-    {ARCOM2, 0xc0},
-    {0x06, 0x88},
-    {0x07, 0xc0},
-    {COM4, 0x87},
-    {0x0e, 0x41},
-    {0x4c, 0x00},
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_DVP},
-
-    //Set the sensor resolution (UXGA, SVGA, CIF)
-    {HSIZE8, 0x32},
-    {VSIZE8, 0x25},
-    {SIZEL, 0x00},
-
-    //Set the image window size >= output size
-    {HSIZE, 0x64},
-    {VSIZE, 0x4a},
-    {XOFFL, 0x00},
-    {YOFFL, 0x00},
-    {VHYX, 0x00},
-    {TEST, 0x00},
-
-    {CTRL2, CTRL2_DCW_EN | 0x1D},
-    {CTRLI, CTRLI_LP_DP | 0x00},
-    //{R_DVP_SP, 0x08},
-    {0, 0}
-};
-
-const DRAM_ATTR uint8_t ov2640_settings_to_svga[][2] = {
-    {BANK_SEL, BANK_SENSOR},
-    {COM7, COM7_RES_SVGA},
-
-    //Set the sensor output window
-    {COM1, 0x0A},
-    {REG32, REG32_SVGA},
-    {HSTART, 0x11},
-    {HSTOP, 0x43},
-    {VSTART, 0x00},
-    {VSTOP, 0x4b},
-
-    //{CLKRC, 0x00},
-    {0x37, 0xc0},
-    {BD50, 0xca},
-    {BD60, 0xa8},
-    {0x5a, 0x23},
-    {0x6d, 0x00},
-    {0x3d, 0x38},
-    {0x39, 0x92},
-    {0x35, 0xda},
-    {0x22, 0x1a},
-    {0x37, 0xc3},
-    {0x23, 0x00},
-    {ARCOM2, 0xc0},
-    {0x06, 0x88},
-    {0x07, 0xc0},
-    {COM4, 0x87},
-    {0x0e, 0x41},
-    {0x42, 0x03},
-    {0x4c, 0x00},
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_DVP},
-
-    //Set the sensor resolution (UXGA, SVGA, CIF)
-    {HSIZE8, 0x64},
-    {VSIZE8, 0x4B},
-    {SIZEL, 0x00},
-
-    //Set the image window size >= output size
-    {HSIZE, 0xC8},
-    {VSIZE, 0x96},
-    {XOFFL, 0x00},
-    {YOFFL, 0x00},
-    {VHYX, 0x00},
-    {TEST, 0x00},
-
-    {CTRL2, CTRL2_DCW_EN | 0x1D},
-    {CTRLI, CTRLI_LP_DP | 0x00},
-    //{R_DVP_SP, 0x08},
-    {0, 0}
-};
-
-const DRAM_ATTR uint8_t ov2640_settings_to_uxga[][2] = {
-    {BANK_SEL, BANK_SENSOR},
-    {COM7, COM7_RES_UXGA},
-
-    //Set the sensor output window
-    {COM1, 0x0F},
-    {REG32, REG32_UXGA},
-    {HSTART, 0x11},
-    {HSTOP, 0x75},
-    {VSTART, 0x01},
-    {VSTOP, 0x97},
-
-    //{CLKRC, 0x00},
-    {0x3d, 0x34},
-    {BD50, 0xbb},
-    {BD60, 0x9c},
-    {0x5a, 0x57},
-    {0x6d, 0x80},
-    {0x39, 0x82},
-    {0x23, 0x00},
-    {0x07, 0xc0},
-    {0x4c, 0x00},
-    {0x35, 0x88},
-    {0x22, 0x0a},
-    {0x37, 0x40},
-    {ARCOM2, 0xa0},
-    {0x06, 0x02},
-    {COM4, 0xb7},
-    {0x0e, 0x01},
-    {0x42, 0x83},
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_DVP},
-
-    //Set the sensor resolution (UXGA, SVGA, CIF)
-    {HSIZE8, 0xc8},
-    {VSIZE8, 0x96},
-    {SIZEL, 0x00},
-
-    //Set the image window size >= output size
-    {HSIZE, 0x90},
-    {VSIZE, 0x2c},
-    {XOFFL, 0x00},
-    {YOFFL, 0x00},
-    {VHYX, 0x88},
-    {TEST, 0x00},
-
-    {CTRL2, CTRL2_DCW_EN | 0x1d},
-    {CTRLI, 0x00},
-    //{R_DVP_SP, 0x06},
-    {0, 0}
-};
-
-const DRAM_ATTR uint8_t ov2640_settings_jpeg3[][2] = {
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_JPEG | RESET_DVP},
-    {IMAGE_MODE, IMAGE_MODE_JPEG_EN | IMAGE_MODE_HREF_VSYNC},
-    {0xD7, 0x03},
-    {0xE1, 0x77},
-    {0xE5, 0x1F},
-    {0xD9, 0x10},
-    {0xDF, 0x80},
-    {0x33, 0x80},
-    {0x3C, 0x10},
-    {0xEB, 0x30},
-    {0xDD, 0x7F},
-    {RESET, 0x00},
-    {0, 0}
-};
-
-static const uint8_t ov2640_settings_yuv422[][2] = {
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_DVP},
-    {IMAGE_MODE, IMAGE_MODE_YUV422},
-    {0xD7, 0x01},
-    {0xE1, 0x67},
-    {RESET, 0x00},
-    {0, 0},
-};
-
-static const uint8_t ov2640_settings_rgb565[][2] = {
-    {BANK_SEL, BANK_DSP},
-    {RESET, RESET_DVP},
-    {IMAGE_MODE, IMAGE_MODE_RGB565},
-    {0xD7, 0x03},
-    {0xE1, 0x77},
-    {RESET, 0x00},
-    {0, 0},
-};
-
-#define NUM_BRIGHTNESS_LEVELS (5)
-static const uint8_t brightness_regs[NUM_BRIGHTNESS_LEVELS + 1][5] = {
-    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA },
-    {0x00, 0x04, 0x09, 0x00, 0x00 }, /* -2 */
-    {0x00, 0x04, 0x09, 0x10, 0x00 }, /* -1 */
-    {0x00, 0x04, 0x09, 0x20, 0x00 }, /*  0 */
-    {0x00, 0x04, 0x09, 0x30, 0x00 }, /* +1 */
-    {0x00, 0x04, 0x09, 0x40, 0x00 }, /* +2 */
-};
-
-#define NUM_CONTRAST_LEVELS (5)
-static const uint8_t contrast_regs[NUM_CONTRAST_LEVELS + 1][7] = {
-    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA, BPDATA, BPDATA },
-    {0x00, 0x04, 0x07, 0x20, 0x18, 0x34, 0x06 }, /* -2 */
-    {0x00, 0x04, 0x07, 0x20, 0x1c, 0x2a, 0x06 }, /* -1 */
-    {0x00, 0x04, 0x07, 0x20, 0x20, 0x20, 0x06 }, /*  0 */
-    {0x00, 0x04, 0x07, 0x20, 0x24, 0x16, 0x06 }, /* +1 */
-    {0x00, 0x04, 0x07, 0x20, 0x28, 0x0c, 0x06 }, /* +2 */
-};
-
-#define NUM_SATURATION_LEVELS (5)
-static const uint8_t saturation_regs[NUM_SATURATION_LEVELS + 1][5] = {
-    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA },
-    {0x00, 0x02, 0x03, 0x28, 0x28 }, /* -2 */
-    {0x00, 0x02, 0x03, 0x38, 0x38 }, /* -1 */
-    {0x00, 0x02, 0x03, 0x48, 0x48 }, /*  0 */
-    {0x00, 0x02, 0x03, 0x58, 0x58 }, /* +1 */
-    {0x00, 0x02, 0x03, 0x68, 0x68 }, /* +2 */
-};
-
-#define NUM_SPECIAL_EFFECTS (7)
-static const uint8_t special_effects_regs[NUM_SPECIAL_EFFECTS + 1][5] = {
-    {BPADDR, BPDATA, BPADDR, BPDATA, BPDATA },
-    {0x00, 0X00, 0x05, 0X80, 0X80 }, /* no effect */
-    {0x00, 0X40, 0x05, 0X80, 0X80 }, /* negative */
-    {0x00, 0X18, 0x05, 0X80, 0X80 }, /* black and white */
-    {0x00, 0X18, 0x05, 0X40, 0XC0 }, /* reddish */
-    {0x00, 0X18, 0x05, 0X40, 0X40 }, /* greenish */
-    {0x00, 0X18, 0x05, 0XA0, 0X40 }, /* blue */
-    {0x00, 0X18, 0x05, 0X40, 0XA6 }, /* retro */
-};
-
-#define NUM_WB_MODES (4)
-static const uint8_t wb_modes_regs[NUM_WB_MODES + 1][3] = {
-    {0XCC, 0XCD, 0XCE },
-    {0x5E, 0X41, 0x54 }, /* sunny */
-    {0x65, 0X41, 0x4F }, /* cloudy */
-    {0x52, 0X41, 0x66 }, /* office */
-    {0x42, 0X3F, 0x71 }, /* home */
-};
-
-#define NUM_AE_LEVELS (5)
-static const uint8_t ae_levels_regs[NUM_AE_LEVELS + 1][3] = {
-    { AEW,  AEB,  VV  },
-    {0x20, 0X18, 0x60 },
-    {0x34, 0X1C, 0x00 },
-    {0x3E, 0X38, 0x81 },
-    {0x48, 0X40, 0x81 },
-    {0x58, 0X50, 0x92 },
-};
-
-const uint8_t agc_gain_tbl[31] = {
-    0x00, 0x10, 0x18, 0x30, 0x34, 0x38, 0x3C, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7A, 0x7C, 0x7E, 0xF0,
-    0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
-};
-
-#endif /* _OV2640_SETTINGS_H_ */
--- a/code/components/esp32-camera-master/sensors/private_include/ov3660.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov3660.h
@@ -1,16 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV3660 driver.
- *
- */
-#ifndef __OV3660_H__
-#define __OV3660_H__
-
-#include "sensor.h"
-
-int ov3660_init(sensor_t *sensor);
-
-#endif // __OV3660_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov3660_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov3660_regs.h
@@ -1,211 +0,0 @@
-/*
- * OV3660 register definitions.
- */
-#ifndef __OV3660_REG_REGS_H__
-#define __OV3660_REG_REGS_H__
-
-/* system control registers */
-#define SYSTEM_CTROL0   0x3008  // Bit[7]: Software reset 
-                                // Bit[6]: Software power down 
-                                // Bit[5]: Reserved 
-                                // Bit[4]: SRB clock SYNC enable 
-                                // Bit[3]: Isolation suspend select 
-                                // Bit[2:0]: Not used
-
-/* output format control registers */
-#define FORMAT_CTRL     0x501F // Format select
-                                // Bit[2:0]:
-                                //  000: YUV422
-                                //  001: RGB
-                                //  010: Dither
-                                //  011: RAW after DPC
-                                //  101: RAW after CIP
-
-/* format control registers */
-#define FORMAT_CTRL00   0x4300
-
-/* frame control registers */
-#define FRAME_CTRL01    0x4201  // Control Passed Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // Bit[3:0]: Frame ON number
-#define FRAME_CTRL02    0x4202  // Control Masked Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // BIT[3:0]: Frame OFF number
-
-/* ISP top control registers */
-#define PRE_ISP_TEST_SETTING_1  0x503D  // Bit[7]: Test enable
-                                        //         0: Test disable
-                                        //         1: Color bar enable
-                                        // Bit[6]: Rolling
-                                        // Bit[5]: Transparent
-                                        // Bit[4]: Square black and white
-                                        // Bit[3:2]: Color bar style
-                                        //         00: Standard 8 color bar
-                                        //         01: Gradual change at vertical mode 1
-                                        //         10: Gradual change at horizontal
-                                        //         11: Gradual change at vertical mode 2
-                                        // Bit[1:0]: Test select
-                                        //         00: Color bar
-                                        //         01: Random data
-                                        //         10: Square data
-                                        //         11: Black image
-
-//exposure = {0x3500[3:0], 0x3501[7:0], 0x3502[7:0]} / 16 × tROW
-
-/* AEC/AGC control functions */
-#define AEC_PK_MANUAL   0x3503  // AEC Manual Mode Control
-                                // Bit[7:6]: Reserved
-                                // Bit[5]: Gain delay option
-                                //         Valid when 0x3503[4]=1’b0
-                                //         0: Delay one frame latch
-                                //         1: One frame latch
-                                // Bit[4:2]: Reserved
-                                // Bit[1]: AGC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-                                // Bit[0]: AEC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-
-//gain = {0x350A[1:0], 0x350B[7:0]} / 16
-
-/* mirror and flip registers */
-#define TIMING_TC_REG20 0x3820  // Timing Control Register
-                                // Bit[2:1]: Vertical flip enable
-                                //         00: Normal
-                                //         11: Vertical flip
-                                // Bit[0]: Vertical binning enable
-#define TIMING_TC_REG21 0x3821  // Timing Control Register
-                                // Bit[5]: Compression Enable
-                                // Bit[2:1]: Horizontal mirror enable
-                                //         00: Normal
-                                //         11: Horizontal mirror
-                                // Bit[0]: Horizontal binning enable
-
-#define CLOCK_POL_CONTROL 0x4740// Bit[5]: PCLK polarity 0: active low
-                                //          1: active high
-                                // Bit[3]: Gate PCLK under VSYNC
-                                // Bit[2]: Gate PCLK under HREF
-                                // Bit[1]: HREF polarity
-                                //          0: active low
-                                //          1: active high
-                                // Bit[0] VSYNC polarity
-                                //          0: active low
-                                //          1: active high
-#define DRIVE_CAPABILITY 0x302c // Bit[7:6]:
-                                //          00: 1x
-                                //          01: 2x
-                                //          10: 3x
-                                //          11: 4x
-
-
-#define X_ADDR_ST_H     0x3800 //Bit[3:0]: X address start[11:8]
-#define X_ADDR_ST_L     0x3801 //Bit[7:0]: X address start[7:0]
-#define Y_ADDR_ST_H     0x3802 //Bit[2:0]: Y address start[10:8]
-#define Y_ADDR_ST_L     0x3803 //Bit[7:0]: Y address start[7:0]
-#define X_ADDR_END_H    0x3804 //Bit[3:0]: X address end[11:8]
-#define X_ADDR_END_L    0x3805 //Bit[7:0]:
-#define Y_ADDR_END_H    0x3806 //Bit[2:0]: Y address end[10:8]
-#define Y_ADDR_END_L    0x3807 //Bit[7:0]:
-// Size after scaling
-#define X_OUTPUT_SIZE_H 0x3808 //Bit[3:0]: DVP output horizontal width[11:8]
-#define X_OUTPUT_SIZE_L 0x3809 //Bit[7:0]:
-#define Y_OUTPUT_SIZE_H 0x380a //Bit[2:0]: DVP output vertical height[10:8]
-#define Y_OUTPUT_SIZE_L 0x380b //Bit[7:0]:
-#define X_TOTAL_SIZE_H  0x380c //Bit[3:0]: Total horizontal size[11:8]
-#define X_TOTAL_SIZE_L  0x380d //Bit[7:0]:
-#define Y_TOTAL_SIZE_H  0x380e //Bit[7:0]: Total vertical size[15:8]
-#define Y_TOTAL_SIZE_L  0x380f //Bit[7:0]:
-#define X_OFFSET_H      0x3810 //Bit[3:0]: ISP horizontal offset[11:8]
-#define X_OFFSET_L      0x3811 //Bit[7:0]:
-#define Y_OFFSET_H      0x3812 //Bit[2:0]: ISP vertical offset[10:8]
-#define Y_OFFSET_L      0x3813 //Bit[7:0]:
-#define X_INCREMENT     0x3814 //Bit[7:4]: Horizontal odd subsample increment
-                               //Bit[3:0]: Horizontal even subsample increment
-#define Y_INCREMENT     0x3815 //Bit[7:4]: Vertical odd subsample increment
-                               //Bit[3:0]: Vertical even subsample increment
-// Size before scaling
-//#define X_INPUT_SIZE    (X_ADDR_END - X_ADDR_ST + 1 - (2 * X_OFFSET))
-//#define Y_INPUT_SIZE    (Y_ADDR_END - Y_ADDR_ST + 1 - (2 * Y_OFFSET))
-
-#define ISP_CONTROL_01   0x5001 // Bit[5]: Scale enable
-                                //          0: Disable
-                                //          1: Enable
-
-#define SCALE_CTRL_1     0x5601 // Bit[6:4]: HDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-                                // Bit[2:0]: VDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-
-#define SCALE_CTRL_2     0x5602 // X_SCALE High Bits
-#define SCALE_CTRL_3     0x5603 // X_SCALE Low Bits
-#define SCALE_CTRL_4     0x5604 // Y_SCALE High Bits
-#define SCALE_CTRL_5     0x5605 // Y_SCALE Low Bits
-#define SCALE_CTRL_6     0x5606 // Bit[3:0]: V Offset
-
-#define PCLK_RATIO       0x3824 // Bit[4:0]: PCLK ratio manual
-#define VFIFO_CTRL0C     0x460C // Bit[1]: PCLK manual enable
-                                //          0: Auto
-                                //          1: Manual by PCLK_RATIO
-
-#define VFIFO_X_SIZE_H   0x4602
-#define VFIFO_X_SIZE_L   0x4603
-#define VFIFO_Y_SIZE_H   0x4604
-#define VFIFO_Y_SIZE_L   0x4605
-
-#define SC_PLLS_CTRL0    0x303a // Bit[7]: PLLS bypass
-#define SC_PLLS_CTRL1    0x303b // Bit[4:0]: PLLS multiplier
-#define SC_PLLS_CTRL2    0x303c // Bit[6:4]: PLLS charge pump control
-                                // Bit[3:0]: PLLS system divider
-#define SC_PLLS_CTRL3    0x303d // Bit[5:4]: PLLS pre-divider
-                                //          00: 1
-                                //          01: 1.5
-                                //          10: 2
-                                //          11: 3
-                                // Bit[2]: PLLS root-divider - 1
-                                // Bit[1:0]: PLLS seld5
-                                //          00: 1
-                                //          01: 1
-                                //          10: 2
-                                //          11: 2.5
-
-#define COMPRESSION_CTRL00 0x4400 //
-#define COMPRESSION_CTRL01 0x4401 //
-#define COMPRESSION_CTRL02 0x4402 //
-#define COMPRESSION_CTRL03 0x4403 //
-#define COMPRESSION_CTRL04 0x4404 //
-#define COMPRESSION_CTRL05 0x4405 //
-#define COMPRESSION_CTRL06 0x4406 //
-#define COMPRESSION_CTRL07 0x4407 // Bit[5:0]: QS
-#define COMPRESSION_ISI_CTRL 0x4408 //
-#define COMPRESSION_CTRL09 0x4409 //
-#define COMPRESSION_CTRL0a 0x440a //
-#define COMPRESSION_CTRL0b 0x440b //
-#define COMPRESSION_CTRL0c 0x440c //
-#define COMPRESSION_CTRL0d 0x440d //
-#define COMPRESSION_CTRL0E 0x440e //
-
-/**
- * @brief register value
- */
-#define TEST_COLOR_BAR  0xC0    /* Enable Color Bar roling Test */
-
-#define AEC_PK_MANUAL_AGC_MANUALEN  0x02    /* Enable AGC Manual enable */
-#define AEC_PK_MANUAL_AEC_MANUALEN  0x01    /* Enable AEC Manual enable */
-
-#define TIMING_TC_REG20_VFLIP   0x06 /* Vertical flip enable */
-#define TIMING_TC_REG21_HMIRROR 0x06 /* Horizontal mirror enable */
-
-#endif // __OV3660_REG_REGS_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov3660_settings.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov3660_settings.h
@@ -1,318 +0,0 @@
-#ifndef _OV3660_SETTINGS_H_
-#define _OV3660_SETTINGS_H_
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_attr.h"
-#include "ov3660_regs.h"
-
-static const ratio_settings_t ratio_table[] = {
-    //  mw,   mh,  sx,  sy,   ex,   ey, ox, oy,   tx,   ty
-    { 2048, 1536,   0,   0, 2079, 1547, 16, 6, 2300, 1564 }, //4x3
-    { 1920, 1280,  64, 128, 2015, 1419, 16, 6, 2172, 1436 }, //3x2
-    { 2048, 1280,   0, 128, 2079, 1419, 16, 6, 2300, 1436 }, //16x10
-    { 1920, 1152,  64, 192, 2015, 1355, 16, 6, 2172, 1372 }, //5x3
-    { 1920, 1080,  64, 242, 2015, 1333, 16, 6, 2172, 1322 }, //16x9
-    { 2048,  880,   0, 328, 2079, 1219, 16, 6, 2300, 1236 }, //21x9
-    { 1920, 1536,  64,   0, 2015, 1547, 16, 6, 2172, 1564 }, //5x4
-    { 1536, 1536, 256,   0, 1823, 1547, 16, 6, 2044, 1564 }, //1x1
-    {  864, 1536, 592,   0, 1487, 1547, 16, 6, 2044, 1564 }  //9x16
-};
-
-#define REG_DLY 0xffff
-#define REGLIST_TAIL 0x0000
-
-static const DRAM_ATTR uint16_t sensor_default_regs[][2] = {
-    {SYSTEM_CTROL0, 0x82},  // software reset
-    {REG_DLY, 10}, // delay 10ms
-
-    {0x3103, 0x13},
-    {SYSTEM_CTROL0, 0x42},
-    {0x3017, 0xff},
-    {0x3018, 0xff},
-    {DRIVE_CAPABILITY, 0xc3},
-    {CLOCK_POL_CONTROL, 0x21},
-
-    {0x3611, 0x01},
-    {0x3612, 0x2d},
-
-    {0x3032, 0x00},
-    {0x3614, 0x80},
-    {0x3618, 0x00},
-    {0x3619, 0x75},
-    {0x3622, 0x80},
-    {0x3623, 0x00},
-    {0x3624, 0x03},
-    {0x3630, 0x52},
-    {0x3632, 0x07},
-    {0x3633, 0xd2},
-    {0x3704, 0x80},
-    {0x3708, 0x66},
-    {0x3709, 0x12},
-    {0x370b, 0x12},
-    {0x3717, 0x00},
-    {0x371b, 0x60},
-    {0x371c, 0x00},
-    {0x3901, 0x13},
-
-    {0x3600, 0x08},
-    {0x3620, 0x43},
-    {0x3702, 0x20},
-    {0x3739, 0x48},
-    {0x3730, 0x20},
-    {0x370c, 0x0c},
-
-    {0x3a18, 0x00},
-    {0x3a19, 0xf8},
-
-    {0x3000, 0x10},
-    {0x3004, 0xef},
-
-    {0x6700, 0x05},
-    {0x6701, 0x19},
-    {0x6702, 0xfd},
-    {0x6703, 0xd1},
-    {0x6704, 0xff},
-    {0x6705, 0xff},
-
-    {0x3c01, 0x80},
-    {0x3c00, 0x04},
-    {0x3a08, 0x00}, {0x3a09, 0x62}, //50Hz Band Width Step (10bit)
-    {0x3a0e, 0x08}, //50Hz Max Bands in One Frame (6 bit)
-    {0x3a0a, 0x00}, {0x3a0b, 0x52}, //60Hz Band Width Step (10bit)
-    {0x3a0d, 0x09}, //60Hz Max Bands in One Frame (6 bit)
-
-    {0x3a00, 0x3a},//night mode off
-    {0x3a14, 0x09},
-    {0x3a15, 0x30},
-    {0x3a02, 0x09},
-    {0x3a03, 0x30},
-
-    {COMPRESSION_CTRL0E, 0x08},
-    {0x4520, 0x0b},
-    {0x460b, 0x37},
-    {0x4713, 0x02},
-    {0x471c, 0xd0},
-    {0x5086, 0x00},
-
-    {0x5002, 0x00},
-    {0x501f, 0x00},
-
-    {SYSTEM_CTROL0, 0x02},
-
-    {0x5180, 0xff},
-    {0x5181, 0xf2},
-    {0x5182, 0x00},
-    {0x5183, 0x14},
-    {0x5184, 0x25},
-    {0x5185, 0x24},
-    {0x5186, 0x16},
-    {0x5187, 0x16},
-    {0x5188, 0x16},
-    {0x5189, 0x68},
-    {0x518a, 0x60},
-    {0x518b, 0xe0},
-    {0x518c, 0xb2},
-    {0x518d, 0x42},
-    {0x518e, 0x35},
-    {0x518f, 0x56},
-    {0x5190, 0x56},
-    {0x5191, 0xf8},
-    {0x5192, 0x04},
-    {0x5193, 0x70},
-    {0x5194, 0xf0},
-    {0x5195, 0xf0},
-    {0x5196, 0x03},
-    {0x5197, 0x01},
-    {0x5198, 0x04},
-    {0x5199, 0x12},
-    {0x519a, 0x04},
-    {0x519b, 0x00},
-    {0x519c, 0x06},
-    {0x519d, 0x82},
-    {0x519e, 0x38},
-
-    {0x5381, 0x1d},
-    {0x5382, 0x60},
-    {0x5383, 0x03},
-    {0x5384, 0x0c},
-    {0x5385, 0x78},
-    {0x5386, 0x84},
-    {0x5387, 0x7d},
-    {0x5388, 0x6b},
-    {0x5389, 0x12},
-    {0x538a, 0x01},
-    {0x538b, 0x98},
-
-    {0x5480, 0x01},
-//    {0x5481, 0x05},
-//    {0x5482, 0x09},
-//    {0x5483, 0x10},
-//    {0x5484, 0x3a},
-//    {0x5485, 0x4c},
-//    {0x5486, 0x5a},
-//    {0x5487, 0x68},
-//    {0x5488, 0x74},
-//    {0x5489, 0x80},
-//    {0x548a, 0x8e},
-//    {0x548b, 0xa4},
-//    {0x548c, 0xb4},
-//    {0x548d, 0xc8},
-//    {0x548e, 0xde},
-//    {0x548f, 0xf0},
-//    {0x5490, 0x15},
-
-    {0x5000, 0xa7},
-    {0x5800, 0x0C},
-    {0x5801, 0x09},
-    {0x5802, 0x0C},
-    {0x5803, 0x0C},
-    {0x5804, 0x0D},
-    {0x5805, 0x17},
-    {0x5806, 0x06},
-    {0x5807, 0x05},
-    {0x5808, 0x04},
-    {0x5809, 0x06},
-    {0x580a, 0x09},
-    {0x580b, 0x0E},
-    {0x580c, 0x05},
-    {0x580d, 0x01},
-    {0x580e, 0x01},
-    {0x580f, 0x01},
-    {0x5810, 0x05},
-    {0x5811, 0x0D},
-    {0x5812, 0x05},
-    {0x5813, 0x01},
-    {0x5814, 0x01},
-    {0x5815, 0x01},
-    {0x5816, 0x05},
-    {0x5817, 0x0D},
-    {0x5818, 0x08},
-    {0x5819, 0x06},
-    {0x581a, 0x05},
-    {0x581b, 0x07},
-    {0x581c, 0x0B},
-    {0x581d, 0x0D},
-    {0x581e, 0x12},
-    {0x581f, 0x0D},
-    {0x5820, 0x0E},
-    {0x5821, 0x10},
-    {0x5822, 0x10},
-    {0x5823, 0x1E},
-    {0x5824, 0x53},
-    {0x5825, 0x15},
-    {0x5826, 0x05},
-    {0x5827, 0x14},
-    {0x5828, 0x54},
-    {0x5829, 0x25},
-    {0x582a, 0x33},
-    {0x582b, 0x33},
-    {0x582c, 0x34},
-    {0x582d, 0x16},
-    {0x582e, 0x24},
-    {0x582f, 0x41},
-    {0x5830, 0x50},
-    {0x5831, 0x42},
-    {0x5832, 0x15},
-    {0x5833, 0x25},
-    {0x5834, 0x34},
-    {0x5835, 0x33},
-    {0x5836, 0x24},
-    {0x5837, 0x26},
-    {0x5838, 0x54},
-    {0x5839, 0x25},
-    {0x583a, 0x15},
-    {0x583b, 0x25},
-    {0x583c, 0x53},
-    {0x583d, 0xCF},
-
-    {0x3a0f, 0x30},
-    {0x3a10, 0x28},
-    {0x3a1b, 0x30},
-    {0x3a1e, 0x28},
-    {0x3a11, 0x60},
-    {0x3a1f, 0x14},
-
-    {0x5302, 0x28},
-    {0x5303, 0x20},
-
-    {0x5306, 0x1c}, //de-noise offset 1
-    {0x5307, 0x28}, //de-noise offset 2
-
-    {0x4002, 0xc5},
-    {0x4003, 0x81},
-    {0x4005, 0x12},
-
-    {0x5688, 0x11},
-    {0x5689, 0x11},
-    {0x568a, 0x11},
-    {0x568b, 0x11},
-    {0x568c, 0x11},
-    {0x568d, 0x11},
-    {0x568e, 0x11},
-    {0x568f, 0x11},
-
-    {0x5580, 0x06},
-    {0x5588, 0x00},
-    {0x5583, 0x40},
-    {0x5584, 0x2c},
-
-    {ISP_CONTROL_01, 0x83}, // turn color matrix, awb and SDE
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_jpeg[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x30}, // YUYV
-    {0x3002, 0x00},//0x1c to 0x00 !!!
-    {0x3006, 0xff},//0xc3 to 0xff !!!
-    {0x471c, 0x50},//0xd0 to 0x50 !!!
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_raw[][2] = {
-    {FORMAT_CTRL00, 0x00}, // RAW
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_grayscale[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x10}, // Y8
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_yuv422[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x30}, // YUYV
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_rgb565[][2] = {
-    {FORMAT_CTRL, 0x01}, // RGB
-    {FORMAT_CTRL00, 0x61}, // RGB565 (BGR)
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint8_t sensor_saturation_levels[9][11] = {
-    {0x1d, 0x60, 0x03, 0x07, 0x48, 0x4f, 0x4b, 0x40, 0x0b, 0x01, 0x98},//-4
-    {0x1d, 0x60, 0x03, 0x08, 0x54, 0x5c, 0x58, 0x4b, 0x0d, 0x01, 0x98},//-3
-    {0x1d, 0x60, 0x03, 0x0a, 0x60, 0x6a, 0x64, 0x56, 0x0e, 0x01, 0x98},//-2
-    {0x1d, 0x60, 0x03, 0x0b, 0x6c, 0x77, 0x70, 0x60, 0x10, 0x01, 0x98},//-1
-    {0x1d, 0x60, 0x03, 0x0c, 0x78, 0x84, 0x7d, 0x6b, 0x12, 0x01, 0x98},//0
-    {0x1d, 0x60, 0x03, 0x0d, 0x84, 0x91, 0x8a, 0x76, 0x14, 0x01, 0x98},//+1
-    {0x1d, 0x60, 0x03, 0x0e, 0x90, 0x9e, 0x96, 0x80, 0x16, 0x01, 0x98},//+2
-    {0x1d, 0x60, 0x03, 0x10, 0x9c, 0xac, 0xa2, 0x8b, 0x17, 0x01, 0x98},//+3
-    {0x1d, 0x60, 0x03, 0x11, 0xa8, 0xb9, 0xaf, 0x96, 0x19, 0x01, 0x98},//+4
-};
-
-static const DRAM_ATTR uint8_t sensor_special_effects[7][4] = {
-    {0x06, 0x40, 0x2c, 0x08},//Normal
-    {0x46, 0x40, 0x28, 0x08},//Negative
-    {0x1e, 0x80, 0x80, 0x08},//Grayscale
-    {0x1e, 0x80, 0xc0, 0x08},//Red Tint
-    {0x1e, 0x60, 0x60, 0x08},//Green Tint
-    {0x1e, 0xa0, 0x40, 0x08},//Blue Tint
-    {0x1e, 0x40, 0xa0, 0x08},//Sepia
-};
-
-#endif
--- a/code/components/esp32-camera-master/sensors/private_include/ov5640.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov5640.h
@@ -1,9 +0,0 @@
-
-#ifndef __OV5640_H__
-#define __OV5640_H__
-
-#include "sensor.h"
-
-int ov5640_init(sensor_t *sensor);
-
-#endif // __OV5640_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov5640_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov5640_regs.h
@@ -1,213 +0,0 @@
-/*
- * OV5640 register definitions.
- */
-#ifndef __OV5640_REG_REGS_H__
-#define __OV5640_REG_REGS_H__
-
-/* system control registers */
-#define SYSTEM_CTROL0   0x3008  // Bit[7]: Software reset 
-                                // Bit[6]: Software power down 
-                                // Bit[5]: Reserved 
-                                // Bit[4]: SRB clock SYNC enable 
-                                // Bit[3]: Isolation suspend select 
-                                // Bit[2:0]: Not used
-
-#define DRIVE_CAPABILITY 0x302c // Bit[7:6]:
-                                //          00: 1x
-                                //          01: 2x
-                                //          10: 3x
-                                //          11: 4x
-
-#define SC_PLLS_CTRL0    0x303a // Bit[7]: PLLS bypass
-#define SC_PLLS_CTRL1    0x303b // Bit[4:0]: PLLS multiplier
-#define SC_PLLS_CTRL2    0x303c // Bit[6:4]: PLLS charge pump control
-                                // Bit[3:0]: PLLS system divider
-#define SC_PLLS_CTRL3    0x303d // Bit[5:4]: PLLS pre-divider
-                                //          00: 1
-                                //          01: 1.5
-                                //          10: 2
-                                //          11: 3
-                                // Bit[2]: PLLS root-divider - 1
-                                // Bit[1:0]: PLLS seld5
-                                //          00: 1
-                                //          01: 1
-                                //          10: 2
-                                //          11: 2.5
-
-/* AEC/AGC control functions */
-#define AEC_PK_MANUAL   0x3503  // AEC Manual Mode Control
-                                // Bit[7:6]: Reserved
-                                // Bit[5]: Gain delay option
-                                //         Valid when 0x3503[4]=1’b0
-                                //         0: Delay one frame latch
-                                //         1: One frame latch
-                                // Bit[4:2]: Reserved
-                                // Bit[1]: AGC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-                                // Bit[0]: AEC manual
-                                //         0: Auto enable
-                                //         1: Manual enable
-
-//gain = {0x350A[1:0], 0x350B[7:0]} / 16
-
-
-#define X_ADDR_ST_H     0x3800 //Bit[3:0]: X address start[11:8]
-#define X_ADDR_ST_L     0x3801 //Bit[7:0]: X address start[7:0]
-#define Y_ADDR_ST_H     0x3802 //Bit[2:0]: Y address start[10:8]
-#define Y_ADDR_ST_L     0x3803 //Bit[7:0]: Y address start[7:0]
-#define X_ADDR_END_H    0x3804 //Bit[3:0]: X address end[11:8]
-#define X_ADDR_END_L    0x3805 //Bit[7:0]:
-#define Y_ADDR_END_H    0x3806 //Bit[2:0]: Y address end[10:8]
-#define Y_ADDR_END_L    0x3807 //Bit[7:0]:
-// Size after scaling
-#define X_OUTPUT_SIZE_H 0x3808 //Bit[3:0]: DVP output horizontal width[11:8]
-#define X_OUTPUT_SIZE_L 0x3809 //Bit[7:0]:
-#define Y_OUTPUT_SIZE_H 0x380a //Bit[2:0]: DVP output vertical height[10:8]
-#define Y_OUTPUT_SIZE_L 0x380b //Bit[7:0]:
-#define X_TOTAL_SIZE_H  0x380c //Bit[3:0]: Total horizontal size[11:8]
-#define X_TOTAL_SIZE_L  0x380d //Bit[7:0]:
-#define Y_TOTAL_SIZE_H  0x380e //Bit[7:0]: Total vertical size[15:8]
-#define Y_TOTAL_SIZE_L  0x380f //Bit[7:0]:
-#define X_OFFSET_H      0x3810 //Bit[3:0]: ISP horizontal offset[11:8]
-#define X_OFFSET_L      0x3811 //Bit[7:0]:
-#define Y_OFFSET_H      0x3812 //Bit[2:0]: ISP vertical offset[10:8]
-#define Y_OFFSET_L      0x3813 //Bit[7:0]:
-#define X_INCREMENT     0x3814 //Bit[7:4]: Horizontal odd subsample increment
-                               //Bit[3:0]: Horizontal even subsample increment
-#define Y_INCREMENT     0x3815 //Bit[7:4]: Vertical odd subsample increment
-                               //Bit[3:0]: Vertical even subsample increment
-// Size before scaling
-//#define X_INPUT_SIZE    (X_ADDR_END - X_ADDR_ST + 1 - (2 * X_OFFSET))
-//#define Y_INPUT_SIZE    (Y_ADDR_END - Y_ADDR_ST + 1 - (2 * Y_OFFSET))
-
-/* mirror and flip registers */
-#define TIMING_TC_REG20 0x3820  // Timing Control Register
-                                // Bit[2:1]: Vertical flip enable
-                                //         00: Normal
-                                //         11: Vertical flip
-                                // Bit[0]: Vertical binning enable
-#define TIMING_TC_REG21 0x3821  // Timing Control Register
-                                // Bit[5]: Compression Enable
-                                // Bit[2:1]: Horizontal mirror enable
-                                //         00: Normal
-                                //         11: Horizontal mirror
-                                // Bit[0]: Horizontal binning enable
-
-#define PCLK_RATIO       0x3824 // Bit[4:0]: PCLK ratio manual
-
-/* frame control registers */
-#define FRAME_CTRL01    0x4201  // Control Passed Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // Bit[3:0]: Frame ON number
-#define FRAME_CTRL02    0x4202  // Control Masked Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
-                                // Bit[7:4]: Not used
-                                // BIT[3:0]: Frame OFF number
-
-/* format control registers */
-#define FORMAT_CTRL00   0x4300
-
-#define CLOCK_POL_CONTROL 0x4740// Bit[5]: PCLK polarity 0: active low
-                                //          1: active high
-                                // Bit[3]: Gate PCLK under VSYNC
-                                // Bit[2]: Gate PCLK under HREF
-                                // Bit[1]: HREF polarity
-                                //          0: active low
-                                //          1: active high
-                                // Bit[0] VSYNC polarity
-                                //          0: active low
-                                //          1: active high
-
-#define ISP_CONTROL_01   0x5001 // Bit[5]: Scale enable
-                                //          0: Disable
-                                //          1: Enable
-
-/* output format control registers */
-#define FORMAT_CTRL     0x501F // Format select
-                                // Bit[2:0]:
-                                //  000: YUV422
-                                //  001: RGB
-                                //  010: Dither
-                                //  011: RAW after DPC
-                                //  101: RAW after CIP
-
-/* ISP top control registers */
-#define PRE_ISP_TEST_SETTING_1  0x503D  // Bit[7]: Test enable
-                                        //         0: Test disable
-                                        //         1: Color bar enable
-                                        // Bit[6]: Rolling
-                                        // Bit[5]: Transparent
-                                        // Bit[4]: Square black and white
-                                        // Bit[3:2]: Color bar style
-                                        //         00: Standard 8 color bar
-                                        //         01: Gradual change at vertical mode 1
-                                        //         10: Gradual change at horizontal
-                                        //         11: Gradual change at vertical mode 2
-                                        // Bit[1:0]: Test select
-                                        //         00: Color bar
-                                        //         01: Random data
-                                        //         10: Square data
-                                        //         11: Black image
-
-//exposure = {0x3500[3:0], 0x3501[7:0], 0x3502[7:0]} / 16 × tROW
-
-#define SCALE_CTRL_1     0x5601 // Bit[6:4]: HDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-                                // Bit[2:0]: VDIV RW
-                                //          DCW scale times
-                                //          000: DCW 1 time
-                                //          001: DCW 2 times
-                                //          010: DCW 4 times
-                                //          100: DCW 8 times
-                                //          101: DCW 16 times
-                                //          Others: DCW 16 times
-
-#define SCALE_CTRL_2     0x5602 // X_SCALE High Bits
-#define SCALE_CTRL_3     0x5603 // X_SCALE Low Bits
-#define SCALE_CTRL_4     0x5604 // Y_SCALE High Bits
-#define SCALE_CTRL_5     0x5605 // Y_SCALE Low Bits
-#define SCALE_CTRL_6     0x5606 // Bit[3:0]: V Offset
-
-#define VFIFO_CTRL0C     0x460C // Bit[1]: PCLK manual enable
-                                //          0: Auto
-                                //          1: Manual by PCLK_RATIO
-
-#define VFIFO_X_SIZE_H   0x4602
-#define VFIFO_X_SIZE_L   0x4603
-#define VFIFO_Y_SIZE_H   0x4604
-#define VFIFO_Y_SIZE_L   0x4605
-
-#define COMPRESSION_CTRL00 0x4400 //
-#define COMPRESSION_CTRL01 0x4401 //
-#define COMPRESSION_CTRL02 0x4402 //
-#define COMPRESSION_CTRL03 0x4403 //
-#define COMPRESSION_CTRL04 0x4404 //
-#define COMPRESSION_CTRL05 0x4405 //
-#define COMPRESSION_CTRL06 0x4406 //
-#define COMPRESSION_CTRL07 0x4407 // Bit[5:0]: QS
-#define COMPRESSION_ISI_CTRL 0x4408 //
-#define COMPRESSION_CTRL09 0x4409 //
-#define COMPRESSION_CTRL0a 0x440a //
-#define COMPRESSION_CTRL0b 0x440b //
-#define COMPRESSION_CTRL0c 0x440c //
-#define COMPRESSION_CTRL0d 0x440d //
-#define COMPRESSION_CTRL0E 0x440e //
-
-/**
- * @brief register value
- */
-#define TEST_COLOR_BAR  0xC0    /* Enable Color Bar roling Test */
-
-#define AEC_PK_MANUAL_AGC_MANUALEN  0x02    /* Enable AGC Manual enable */
-#define AEC_PK_MANUAL_AEC_MANUALEN  0x01    /* Enable AEC Manual enable */
-
-#define TIMING_TC_REG20_VFLIP   0x06 /* Vertical flip enable */
-#define TIMING_TC_REG21_HMIRROR 0x06 /* Horizontal mirror enable */
-
-#endif // __OV3660_REG_REGS_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov5640_settings.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov5640_settings.h
@@ -1,334 +0,0 @@
-#ifndef _OV5640_SETTINGS_H_
-#define _OV5640_SETTINGS_H_
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_attr.h"
-#include "ov5640_regs.h"
-
-static const ratio_settings_t ratio_table[] = {
-    //  mw,   mh,  sx,  sy,   ex,   ey, ox, oy,   tx,   ty
-    { 2560, 1920,   0,   0, 2623, 1951, 32, 16, 2844, 1968 }, //4x3
-    { 2560, 1704,   0, 110, 2623, 1843, 32, 16, 2844, 1752 }, //3x2
-    { 2560, 1600,   0, 160, 2623, 1791, 32, 16, 2844, 1648 }, //16x10
-    { 2560, 1536,   0, 192, 2623, 1759, 32, 16, 2844, 1584 }, //5x3
-    { 2560, 1440,   0, 240, 2623, 1711, 32, 16, 2844, 1488 }, //16x9
-    { 2560, 1080,   0, 420, 2623, 1531, 32, 16, 2844, 1128 }, //21x9
-    { 2400, 1920,  80,   0, 2543, 1951, 32, 16, 2684, 1968 }, //5x4
-    { 1920, 1920, 320,   0, 2543, 1951, 32, 16, 2684, 1968 }, //1x1
-    { 1088, 1920, 736,   0, 1887, 1951, 32, 16, 1884, 1968 }  //9x16
-};
-
-#define REG_DLY 0xffff
-#define REGLIST_TAIL 0x0000
-
-static const DRAM_ATTR uint16_t sensor_default_regs[][2] = {
-    {SYSTEM_CTROL0, 0x82},  // software reset
-    {REG_DLY, 10}, // delay 10ms
-    {SYSTEM_CTROL0, 0x42},  // power down
-
-    //enable pll
-    {0x3103, 0x13},
-
-    //io direction
-    {0x3017, 0xff},
-    {0x3018, 0xff},
-
-    {DRIVE_CAPABILITY, 0xc3},
-    {CLOCK_POL_CONTROL, 0x21},
-
-    {0x4713, 0x02},//jpg mode select
-
-    {ISP_CONTROL_01, 0x83}, // turn color matrix, awb and SDE
-
-    //sys reset
-    {0x3000, 0x00},
-    {0x3002, 0x1c},
-
-    //clock enable
-    {0x3004, 0xff},
-    {0x3006, 0xc3},
-
-    //isp control
-    {0x5000, 0xa7},
-    {ISP_CONTROL_01, 0xa3},//+scaling?
-    {0x5003, 0x08},//special_effect
-
-    //unknown
-    {0x370c, 0x02},//!!IMPORTANT
-    {0x3634, 0x40},//!!IMPORTANT
-
-    //AEC/AGC
-    {0x3a02, 0x03},
-    {0x3a03, 0xd8},
-    {0x3a08, 0x01},
-    {0x3a09, 0x27},
-    {0x3a0a, 0x00},
-    {0x3a0b, 0xf6},
-    {0x3a0d, 0x04},
-    {0x3a0e, 0x03},
-    {0x3a0f, 0x30},//ae_level
-    {0x3a10, 0x28},//ae_level
-    {0x3a11, 0x60},//ae_level
-    {0x3a13, 0x43},
-    {0x3a14, 0x03},
-    {0x3a15, 0xd8},
-    {0x3a18, 0x00},//gainceiling
-    {0x3a19, 0xf8},//gainceiling
-    {0x3a1b, 0x30},//ae_level
-    {0x3a1e, 0x26},//ae_level
-    {0x3a1f, 0x14},//ae_level
-
-    //vcm debug
-    {0x3600, 0x08},
-    {0x3601, 0x33},
-
-    //50/60Hz
-    {0x3c01, 0xa4},
-    {0x3c04, 0x28},
-    {0x3c05, 0x98},
-    {0x3c06, 0x00},
-    {0x3c07, 0x08},
-    {0x3c08, 0x00},
-    {0x3c09, 0x1c},
-    {0x3c0a, 0x9c},
-    {0x3c0b, 0x40},
-
-    {0x460c, 0x22},//disable jpeg footer
-
-    //BLC
-    {0x4001, 0x02},
-    {0x4004, 0x02},
-
-    //AWB
-    {0x5180, 0xff},
-    {0x5181, 0xf2},
-    {0x5182, 0x00},
-    {0x5183, 0x14},
-    {0x5184, 0x25},
-    {0x5185, 0x24},
-    {0x5186, 0x09},
-    {0x5187, 0x09},
-    {0x5188, 0x09},
-    {0x5189, 0x75},
-    {0x518a, 0x54},
-    {0x518b, 0xe0},
-    {0x518c, 0xb2},
-    {0x518d, 0x42},
-    {0x518e, 0x3d},
-    {0x518f, 0x56},
-    {0x5190, 0x46},
-    {0x5191, 0xf8},
-    {0x5192, 0x04},
-    {0x5193, 0x70},
-    {0x5194, 0xf0},
-    {0x5195, 0xf0},
-    {0x5196, 0x03},
-    {0x5197, 0x01},
-    {0x5198, 0x04},
-    {0x5199, 0x12},
-    {0x519a, 0x04},
-    {0x519b, 0x00},
-    {0x519c, 0x06},
-    {0x519d, 0x82},
-    {0x519e, 0x38},
-
-    //color matrix (Saturation)
-    {0x5381, 0x1e},
-    {0x5382, 0x5b},
-    {0x5383, 0x08},
-    {0x5384, 0x0a},
-    {0x5385, 0x7e},
-    {0x5386, 0x88},
-    {0x5387, 0x7c},
-    {0x5388, 0x6c},
-    {0x5389, 0x10},
-    {0x538a, 0x01},
-    {0x538b, 0x98},
-
-    //CIP control (Sharpness)
-    {0x5300, 0x10},//sharpness
-    {0x5301, 0x10},//sharpness
-    {0x5302, 0x18},//sharpness
-    {0x5303, 0x19},//sharpness
-    {0x5304, 0x10},
-    {0x5305, 0x10},
-    {0x5306, 0x08},//denoise
-    {0x5307, 0x16},
-    {0x5308, 0x40},
-    {0x5309, 0x10},//sharpness
-    {0x530a, 0x10},//sharpness
-    {0x530b, 0x04},//sharpness
-    {0x530c, 0x06},//sharpness
-
-    //GAMMA
-    {0x5480, 0x01},
-    {0x5481, 0x00},
-    {0x5482, 0x1e},
-    {0x5483, 0x3b},
-    {0x5484, 0x58},
-    {0x5485, 0x66},
-    {0x5486, 0x71},
-    {0x5487, 0x7d},
-    {0x5488, 0x83},
-    {0x5489, 0x8f},
-    {0x548a, 0x98},
-    {0x548b, 0xa6},
-    {0x548c, 0xb8},
-    {0x548d, 0xca},
-    {0x548e, 0xd7},
-    {0x548f, 0xe3},
-    {0x5490, 0x1d},
-
-    //Special Digital Effects (SDE) (UV adjust)
-    {0x5580, 0x06},//enable brightness and contrast
-    {0x5583, 0x40},//special_effect
-    {0x5584, 0x10},//special_effect
-    {0x5586, 0x20},//contrast
-    {0x5587, 0x00},//brightness
-    {0x5588, 0x00},//brightness
-    {0x5589, 0x10},
-    {0x558a, 0x00},
-    {0x558b, 0xf8},
-    {0x501d, 0x40},// enable manual offset of contrast
-
-    //power on
-    {0x3008, 0x02},
-
-    //50Hz
-    {0x3c00, 0x04},
-    
-    {REG_DLY, 300},
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_jpeg[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x30}, // YUYV
-    {0x3002, 0x00},//0x1c to 0x00 !!!
-    {0x3006, 0xff},//0xc3 to 0xff !!!
-    {0x471c, 0x50},//0xd0 to 0x50 !!!
-    {REGLIST_TAIL, 0x00}, // tail
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_raw[][2] = {
-    {FORMAT_CTRL, 0x03}, // RAW (DPC)
-    {FORMAT_CTRL00, 0x00}, // RAW
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_grayscale[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x10}, // Y8
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_yuv422[][2] = {
-    {FORMAT_CTRL, 0x00}, // YUV422
-    {FORMAT_CTRL00, 0x30}, // YUYV
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint16_t sensor_fmt_rgb565[][2] = {
-    {FORMAT_CTRL, 0x01}, // RGB
-    {FORMAT_CTRL00, 0x61}, // RGB565 (BGR)
-    {REGLIST_TAIL, 0x00}
-};
-
-static const DRAM_ATTR uint8_t sensor_saturation_levels[9][11] = {
-    {0x1d, 0x60, 0x03, 0x07, 0x48, 0x4f, 0x4b, 0x40, 0x0b, 0x01, 0x98},//-4
-    {0x1d, 0x60, 0x03, 0x08, 0x54, 0x5c, 0x58, 0x4b, 0x0d, 0x01, 0x98},//-3
-    {0x1d, 0x60, 0x03, 0x0a, 0x60, 0x6a, 0x64, 0x56, 0x0e, 0x01, 0x98},//-2
-    {0x1d, 0x60, 0x03, 0x0b, 0x6c, 0x77, 0x70, 0x60, 0x10, 0x01, 0x98},//-1
-    {0x1d, 0x60, 0x03, 0x0c, 0x78, 0x84, 0x7d, 0x6b, 0x12, 0x01, 0x98},//0
-    {0x1d, 0x60, 0x03, 0x0d, 0x84, 0x91, 0x8a, 0x76, 0x14, 0x01, 0x98},//+1
-    {0x1d, 0x60, 0x03, 0x0e, 0x90, 0x9e, 0x96, 0x80, 0x16, 0x01, 0x98},//+2
-    {0x1d, 0x60, 0x03, 0x10, 0x9c, 0xac, 0xa2, 0x8b, 0x17, 0x01, 0x98},//+3
-    {0x1d, 0x60, 0x03, 0x11, 0xa8, 0xb9, 0xaf, 0x96, 0x19, 0x01, 0x98},//+4
-};
-
-static const DRAM_ATTR uint8_t sensor_special_effects[7][4] = {
-    {0x06, 0x40, 0x2c, 0x08},//Normal
-    {0x46, 0x40, 0x28, 0x08},//Negative
-    {0x1e, 0x80, 0x80, 0x08},//Grayscale
-    {0x1e, 0x80, 0xc0, 0x08},//Red Tint
-    {0x1e, 0x60, 0x60, 0x08},//Green Tint
-    {0x1e, 0xa0, 0x40, 0x08},//Blue Tint
-    {0x1e, 0x40, 0xa0, 0x08},//Sepia
-};
-
-static const DRAM_ATTR uint16_t sensor_regs_gamma0[][2] = {
-    {0x5480, 0x01},
-    {0x5481, 0x08},
-    {0x5482, 0x14},
-    {0x5483, 0x28},
-    {0x5484, 0x51},
-    {0x5485, 0x65},
-    {0x5486, 0x71},
-    {0x5487, 0x7d},
-    {0x5488, 0x87},
-    {0x5489, 0x91},
-    {0x548a, 0x9a},
-    {0x548b, 0xaa},
-    {0x548c, 0xb8},
-    {0x548d, 0xcd},
-    {0x548e, 0xdd},
-    {0x548f, 0xea},
-    {0x5490, 0x1d}
-};
-
-static const DRAM_ATTR uint16_t sensor_regs_gamma1[][2] = {
-    {0x5480, 0x1},
-    {0x5481, 0x0},
-    {0x5482, 0x1e},
-    {0x5483, 0x3b},
-    {0x5484, 0x58},
-    {0x5485, 0x66},
-    {0x5486, 0x71},
-    {0x5487, 0x7d},
-    {0x5488, 0x83},
-    {0x5489, 0x8f},
-    {0x548a, 0x98},
-    {0x548b, 0xa6},
-    {0x548c, 0xb8},
-    {0x548d, 0xca},
-    {0x548e, 0xd7},
-    {0x548f, 0xe3},
-    {0x5490, 0x1d}
-};
-
-static const DRAM_ATTR uint16_t sensor_regs_awb0[][2] = {
-    {0x5180, 0xff},
-    {0x5181, 0xf2},
-    {0x5182, 0x00},
-    {0x5183, 0x14},
-    {0x5184, 0x25},
-    {0x5185, 0x24},
-    {0x5186, 0x09},
-    {0x5187, 0x09},
-    {0x5188, 0x09},
-    {0x5189, 0x75},
-    {0x518a, 0x54},
-    {0x518b, 0xe0},
-    {0x518c, 0xb2},
-    {0x518d, 0x42},
-    {0x518e, 0x3d},
-    {0x518f, 0x56},
-    {0x5190, 0x46},
-    {0x5191, 0xf8},
-    {0x5192, 0x04},
-    {0x5193, 0x70},
-    {0x5194, 0xf0},
-    {0x5195, 0xf0},
-    {0x5196, 0x03},
-    {0x5197, 0x01},
-    {0x5198, 0x04},
-    {0x5199, 0x12},
-    {0x519a, 0x04},
-    {0x519b, 0x00},
-    {0x519c, 0x06},
-    {0x519d, 0x82},
-    {0x519e, 0x38}
-};
-
-#endif
--- a/code/components/esp32-camera-master/sensors/private_include/ov7670.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov7670.h
@@ -1,14 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV7670 driver.
- *
- */
-#ifndef __OV7670_H__
-#define __OV7670_H__
-#include "sensor.h"
-
-int ov7670_init(sensor_t *sensor);
-#endif // __OV7670_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov7670_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov7670_regs.h
@@ -1,354 +0,0 @@
-/*
- * This file is for the OpenMV project so the OV7670 can be used
- * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
- *
- * OV7670 register definitions.
- */
-#ifndef __OV7670_REG_REGS_H__
-#define __OV7670_REG_REGS_H__
-#define GAIN                    0x00 /* AGC – Gain control gain setting  */
-#define BLUE                    0x01 /* AWB – Blue channel gain setting  */
-#define RED                     0x02 /* AWB – Red channel gain setting   */
-#define VREF                    0x03 /* AWB – Green channel gain setting */
-#define COM1			        0x04 /* Common Control 1 */
-#define BAVG                    0x05 /* U/B Average Level   */
-#define GAVG                    0x06 /* Y/Gb Average Level  */
-#define AECH                    0x07 /* Exposure VAlue - AEC MSB 5 bits  */
-#define RAVG                    0x08 /* V/R Average Level */
-
-#define COM2                    0x09 /* Common Control 2 */
-#define COM2_SOFT_SLEEP         0x10 /* Soft sleep mode  */
-#define COM2_OUT_DRIVE_1x       0x00 /* Output drive capability 1x */
-#define COM2_OUT_DRIVE_2x       0x01 /* Output drive capability 2x */
-#define COM2_OUT_DRIVE_3x       0x02 /* Output drive capability 3x */
-#define COM2_OUT_DRIVE_4x       0x03 /* Output drive capability 4x */
-
-#define REG_PID                 0x0A /* Product ID Number MSB */
-#define REG_VER                 0x0B /* Product ID Number LSB */
-
-#define COM3                    0x0C /* Common Control 3 		 */
-#define COM3_SWAP_OUT           0x40 /* Output data MSB/LSB swap */
-#define COM3_TRI_CLK            0x20 /* Tri-state output clock   */
-#define COM3_TRI_DATA           0x10 /* Tri-state option output  */
-#define COM3_SCALE_EN           0x08 /* Scale enable             */
-#define COM3_DCW                0x04 /* DCW enable               */
-
-#define COM4                    0x0D /* Common Control 4         */
-#define COM4_PLL_BYPASS         0x00 /* Bypass PLL               */
-#define COM4_PLL_4x             0x40 /* PLL frequency 4x         */
-#define COM4_PLL_6x             0x80 /* PLL frequency 6x         */
-#define COM4_PLL_8x             0xc0 /* PLL frequency 8x         */
-#define COM4_AEC_FULL           0x00 /* AEC evaluate full window */
-#define COM4_AEC_1_2            0x10 /* AEC evaluate 1/2 window  */
-#define COM4_AEC_1_4            0x20 /* AEC evaluate 1/4 window  */
-#define COM4_AEC_2_3            0x30 /* AEC evaluate 2/3 window  */
-
-#define COM5                    0x0E /* Common Control 5 */
-#define COM5_AFR                0x80 /* Auto frame rate control ON/OFF selection (night mode) */
-#define COM5_AFR_SPEED          0x40 /* Auto frame rate control speed selection */
-#define COM5_AFR_0              0x00 /* No reduction of frame rate          */
-#define COM5_AFR_1_2            0x10 /* Max reduction to 1/2 frame rate     */
-#define COM5_AFR_1_4            0x20 /* Max reduction to 1/4 frame rate     */
-#define COM5_AFR_1_8            0x30 /* Max reduction to 1/8 frame rate     */
-#define COM5_AFR_4x             0x04 /* Add frame when AGC reaches 4x gain  */
-#define COM5_AFR_8x             0x08 /* Add frame when AGC reaches 8x gain  */
-#define COM5_AFR_16x            0x0c /* Add frame when AGC reaches 16x gain */
-#define COM5_AEC_NO_LIMIT       0x01 /* No limit to AEC increase step       */
-
-#define COM6                    0x0F /* Common Control 6 */
-#define COM6_AUTO_WINDOW        0x01 /* Auto window setting ON/OFF selection when format changes */
-
-#define AEC                     0x10 /* AEC[7:0] (see register AECH for AEC[15:8]) */
-#define CLKRC                   0x11 /* Internal Clock */
-
-#define COM7                    0x12 /* Common Control 7         */
-#define COM7_RESET              0x80 /* SCCB Register Reset      */
-#define COM7_RES_VGA            0x00 /* Resolution VGA           */
-#define COM7_RES_QVGA           0x40 /* Resolution QVGA          */
-#define COM7_BT656              0x20 /* BT.656 protocol ON/OFF   */
-#define COM7_SENSOR_RAW         0x10 /* Sensor RAW               */
-#define COM7_FMT_GBR422         0x00 /* RGB output format GBR422 */
-#define COM7_FMT_RGB565         0x04 /* RGB output format RGB565 */
-#define COM7_FMT_RGB555         0x08 /* RGB output format RGB555 */
-#define COM7_FMT_RGB444         0x0C /* RGB output format RGB444 */
-#define COM7_FMT_YUV            0x00 /* Output format YUV        */
-#define COM7_FMT_P_BAYER        0x01 /* Output format Processed Bayer RAW */
-#define COM7_FMT_RGB            0x04 /* Output format RGB        */
-#define COM7_FMT_R_BAYER        0x03 /* Output format Bayer RAW  */
-#define COM7_SET_FMT(r, x)      ((r&0xFC)|((x&0x5)<<0))
-
-#define COM8                    0x13 /* Common Control 8                */
-#define COM8_FAST_AUTO          0x80 /* Enable fast AGC/AEC algorithm   */
-#define COM8_STEP_VSYNC         0x00 /* AEC - Step size limited to vertical blank */
-#define COM8_STEP_UNLIMIT       0x40 /* AEC - Step size unlimited step size       */
-#define COM8_BANDF_EN           0x20 /* Banding filter ON/OFF */
-#define COM8_AEC_BANDF          0x10 /* Enable AEC below banding value */
-#define COM8_AEC_FINE_EN        0x08 /* Fine AEC ON/OFF control */
-#define COM8_AGC_EN             0x04 /* AGC Enable */
-#define COM8_AWB_EN             0x02 /* AWB Enable */
-#define COM8_AEC_EN             0x01 /* AEC Enable */
-#define COM8_SET_AGC(r, x)      ((r&0xFB)|((x&0x1)<<2))
-#define COM8_SET_AWB(r, x)      ((r&0xFD)|((x&0x1)<<1))
-#define COM8_SET_AEC(r, x)      ((r&0xFE)|((x&0x1)<<0))
-
-#define COM9                    0x14 /* Common Control 9 */
-#define COM9_HISTO_AVG          0x80 /* Histogram or average based AEC/AGC selection */
-#define COM9_AGC_GAIN_2x        0x00 /* Automatic Gain Ceiling 2x  */
-#define COM9_AGC_GAIN_4x        0x10 /* Automatic Gain Ceiling 4x  */
-#define COM9_AGC_GAIN_8x        0x20 /* Automatic Gain Ceiling 8x  */
-#define COM9_AGC_GAIN_16x       0x30 /* Automatic Gain Ceiling 16x */
-#define COM9_AGC_GAIN_32x       0x40 /* Automatic Gain Ceiling 32x */
-#define COM9_DROP_VSYNC         0x04 /* Drop VSYNC output of corrupt frame */
-#define COM9_DROP_HREF          0x02 /* Drop HREF output of corrupt frame  */
-#define COM9_SET_AGC(r, x)      ((r&0x8F)|((x&0x07)<<4))
-
-#define COM10                   0x15 /* Common Control 10 */
-#define COM10_NEGATIVE          0x80 /* Output negative data */
-#define COM10_HSYNC_EN          0x40 /* HREF changes to HSYNC */
-#define COM10_PCLK_FREE         0x00 /* PCLK output option: free running PCLK */
-#define COM10_PCLK_MASK         0x20 /* PCLK output option: masked during horizontal blank  */
-#define COM10_PCLK_REV          0x10 /* PCLK reverse */
-#define COM10_HREF_REV          0x08 /* HREF reverse */
-#define COM10_VSYNC_FALLING     0x00 /* VSYNC changes on falling edge of PCLK */
-#define COM10_VSYNC_RISING      0x04 /* VSYNC changes on rising edge of PCLK */
-#define COM10_VSYNC_NEG         0x02 /* VSYNC negative */
-#define COM10_OUT_RANGE_8       0x01 /* Output data range: Full range */
-#define COM10_OUT_RANGE_10      0x00 /* Output data range: Data from [10] to [F0] (8 MSBs) */
-
-#define RSVD_16                 0x16 /* Reserved register */
-
-#define HSTART                  0x17  /* Horizontal Frame (HREF column) Start high 8-bit(low 3 bits are at HREF[2:0]) */
-#define HSTOP                   0x18  /* Horizontal Frame (HREF column) end high 8-bit (low 3 bits are at HREF[5:3])  */
-#define VSTART                  0x19  /* Vertical Frame (row) Start high 8-bit (low 2 bits are at VREF[1:0]) */
-#define VSTOP                   0x1A  /* Vertical Frame (row) End high 8-bit (low 2 bits are at VREF[3:2]) */
-#define PSHFT                   0x1B  /* Data Format - Pixel Delay Select */
-#define REG_MIDH                0x1C  /* Manufacturer ID Byte – High */
-#define REG_MIDL                0x1D  /* Manufacturer ID Byte – Low */
-
-#define MVFP			        0x1E  /* Mirror/Vflip Enable */
-#define   MVFP_MIRROR	        0x20  /* Mirror image */
-#define   MVFP_FLIP	            0x10  /* Vertical flip */
-#define   MVFP_SUN	            0x02  /* Black sun enable */
-#define MVFP_SET_MIRROR(r,x)	((r&0xDF)|((x&1)<<5)) /* change only bit5 according to x */
-#define MVFP_SET_FLIP(r,x)	    ((r&0xEF)|((x&1)<<4)) /* change only bit4 according to x */
-
-#define LAEC                    0x1F /* Fine AEC Value - defines exposure value less than one row period (Reserved?) */
-#define ADCCTR0                 0x20 /* ADC control */
-#define ADCCTR1			        0x21 /* reserved */
-#define ADCCTR2                 0x22 /* reserved */
-#define ADCCTR3                 0x23 /* reserved */
-#define AEW                     0x24 /* AGC/AEC - Stable Operating Region (Upper Limit) */
-#define AEB                     0x25 /* AGC/AEC - Stable Operating Region (Lower Limit) */
-#define VPT                     0x26 /* AGC/AEC Fast Mode Operating Region */
-#define BBIAS 			        0x27 /* B channel signal output bias (effective only when COM6[3]=1) */
-#define GbBIAS                  0x28 /* Gb channel signal output bias (effective only when COM6[3]=1) */
-#define RSVD_29                 0x29 /* reserved */
-#define EXHCH                   0x2A /* Dummy Pixel Insert MSB */
-#define EXHCL                   0x2B /* Dummy Pixel Insert LSB */
-#define RBIAS                   0x2C /* R channel signal output bias (effective only when COM6[3]=1) */
-#define ADVFL                   0x2D /* LSB of Insert Dummy Rows in Vertical Sync (1 bit equals 1 row)  */
-#define ADVFH                   0x2E /* MSB of Insert Dummy Rows in Vertical Sync */
-#define YAVE                    0x2F /* Y/G Channel Average Value */
-#define HSYST                   0x30 /* HSync rising edge delay */
-#define HSYEN                   0x31 /* HSync falling edge delay  */
-#define HREF                    0x32 /* Image Start and Size Control DIFFERENT CONTROL SEQUENCE	 */
-#define CHLF                    0x33 /* Array Current control  */
-#define ARBLM                   0x34 /* Array reference control */
-#define RSVD_35                 0x35 /* Reserved */
-#define RSVD_36                 0x36 /* Reserved */
-#define ADC                     0x37 /* ADC control */
-#define ACOM                    0x38 /* ADC and analog common mode control */
-#define OFON                    0x39 /* ADC offset control */
-#define TSLB                    0x3A /* Line buffer test option  */
-
-#define COM11                   0x3B /* Common control 11 */
-#define   COM11_EXP		        0x02
-#define   COM11_HZAUTO		    0x10 /* Auto detect 50/60 Hz */
-
-#define COM12                   0x3C /* Common control 12 */
-
-#define COM13                   0x3D /* Common control 13 */
-#define   COM13_GAMMA	        0x80 /* Gamma enable */
-#define	  COM13_UVSAT	        0x40 /* UV saturation auto adjustment */
-
-#define COM14                   0x3E /* Common Control 14 */
-
-#define EDGE                    0x3F /* edge enhancement adjustment */
-#define COM15                   0x40 /* Common Control 15 DIFFERENT CONTROLS */
-#define COM15_SET_RGB565(r,x)	((r&0xEF)|((x&1)<<4)) /* set rgb565 mode */
-#define   COM15_RGB565	        0x10 /* RGB565 output */
-#define   COM15_R00FF           0xC0 /* Output range: [00] to [FF] */
-
-#define COM16                   0x41 /* Common Control 16 DIFFERENT CONTROLS */
-#define COM16_AWBGAIN		    0x08 /* AWB gain enable */
-#define COM17                   0x42 /* Common Control 17   */
-
-#define AWBC1                   0x43 /* Reserved */
-#define AWBC2                  	0x44 /* Reserved */
-#define AWBC3                  	0x45 /* Reserved */
-#define AWBC4                   0x46 /* Reserved */
-#define AWBC5                  	0x47 /* Reserved */
-#define AWBC6                  	0x48 /* Reserved */
-
-#define RSVD_49			        0x49 /* Reserved */
-#define RSVD_4A			        0x4A /* Reserved */
-
-#define REG4B                   0x4B /* Register 4B */
-#define DNSTH                   0x4C /* Denoise strength */
-
-#define RSVD_4D			        0x4D /* Reserved */
-#define RSVD_4E			        0x4E /* Reserved */
-
-#define MTX1                    0x4F /* Matrix coefficient 1 */
-#define MTX2                    0x50 /* Matrix coefficient 2 */
-#define MTX3                    0x51 /* Matrix coefficient 3 */
-#define MTX4                    0x52 /* Matrix coefficient 4 */
-#define MTX5                    0x53 /* Matrix coefficient 5 */
-#define MTX6                    0x54 /* Matrix coefficient 6 */
-#define BRIGHTNESS              0x55 /* Brightness control */
-#define CONTRAST		        0x56 /* Contrast control */
-#define CONTRASCENTER           0x57 /* Contrast center */
-#define MTXS			        0x58 /* Matrix coefficient sign for coefficient 5 to 0*/
-
-#define RSVD_59			        0x59 /* Reserved */
-#define RSVD_5A			        0x5A /* Reserved */
-#define RSVD_5B			        0x5B /* Reserved */
-#define RSVD_5C			        0x5C /* Reserved */
-#define RSVD_5D			        0x5D /* Reserved */
-#define RSVD_5E			        0x5E /* Reserved */
-#define RSVD_5F			        0x5F /* Reserved */
-#define RSVD_60			        0x60 /* Reserved */
-#define RSVD_61			        0x61 /* Reserved */
-
-#define LCC1                    0x62 /* Lens correction option 1  */
-
-#define LCC2                    0x63 /* Lens correction option 2 */
-#define LCC3 			        0x64 /* Lens correction option 3 */
-#define LCC4			        0x65 /* Lens correction option 4 */
-#define LCC5			        0x66 /* Lens correction option 5 */
-
-#define MANU       		        0x67 /* Manual U Value      */
-#define MANV      		        0x68 /* Manual V Value */
-#define GFIX                    0x69 /* Fix gain control */
-#define GGAIN                   0x6A /* G channel AWB gain */
-
-#define DBLV               	    0x6B /* PLL and clock ? */
-
-#define AWBCTR3               	0x6C /* AWB Control 3  */
-#define AWBCTR2	                0x6D /* AWB Control 2  */
-#define AWBCTR1                 0x6E /* AWB Control 1  */
-#define AWBCTR0                 0x6F /* AWB Control 0  */
-#define SCALING_XSC             0x70 /* test pattern and horizontal scaling factor */
-#define SCALING_XSC_CBAR(r)	(r&0x7F) /* make sure bit7 is 0 for color bar */
-#define SCALING_YSC             0x71 /* test pattern and vertical scaling factor */
-#define SCALING_YSC_CBAR(r,x)	((r&0x7F)|((x&1)<<7)) /* change bit7 for color bar on/off */
-#define SCALING_DCWCTR          0x72 /* DCW control */
-#define SCALING_PCLK_DIV        0x73 /*  */
-#define REG74                   0x74 /*  */
-#define REG75                   0x75 /*  */
-#define REG76                   0x76 /*  */
-#define REG77	             	0x77 /*  */
-
-#define RSVD_78      		    0x78 /* Reserved */
-#define RSVD_79              	0x79 /* Reserved */
-
-#define SLOP	                0x7A /* Gamma curve highest segment slope */
-#define GAM1	                0x7B /* Gamma Curve 1st Segment Input End Point 0x04 Output Value */
-#define GAM2	                0x7C /* Gamma Curve 2nd Segment Input End Point 0x08 Output Value */
-#define GAM3                    0x7D /* Gamma Curve 3rd Segment Input End Point 0x10 Output Value */
-#define GAM4                    0x7E /* Gamma Curve 4th Segment Input End Point 0x20 Output Value */
-#define GAM5                    0x7F /* Gamma Curve 5th Segment Input End Point 0x28 Output Value */
-#define GAM6                    0x80 /* Gamma Curve 6rd Segment Input End Point 0x30 Output Value */
-#define GAM7                    0x81 /* Gamma Curve 7th Segment Input End Point 0x38 Output Value */
-#define GAM8                    0x82 /* Gamma Curve 8th Segment Input End Point 0x40 Output Value */
-#define GAM9                    0x83 /* Gamma Curve 9th Segment Input End Point 0x48 Output Value */
-#define GAM10                   0x84 /* Gamma Curve 10th Segment Input End Point 0x50 Output Value */
-#define GAM11                   0x85 /* Gamma Curve 11th Segment Input End Point 0x60 Output Value */
-#define GAM12                   0x86 /* Gamma Curve 12th Segment Input End Point 0x70 Output Value */
-#define GAM13                   0x87 /* Gamma Curve 13th Segment Input End Point 0x90 Output Value */
-#define GAM14                   0x88 /* Gamma Curve 14th Segment Input End Point 0xB0 Output Value */
-#define GAM15                   0x89 /* Gamma Curve 15th Segment Input End Point 0xD0 Output Value */
-
-#define RSVD_8A      		    0x8A /* Reserved */
-#define RSVD_8B              	0x8B /* Reserved */
-
-#define RGB444                  0x8C /*  */
-
-#define RSVD_8D      		    0x8D /* Reserved */
-#define RSVD_8E              	0x8E /* Reserved */
-#define RSVD_8F      		    0x8F /* Reserved */
-#define RSVD_90              	0x90 /* Reserved */
-#define RSVD_91      		    0x91 /* Reserved */
-
-#define DM_LNL                  0x92 /* Dummy line low 8 bit */
-#define DM_LNH                  0x93 /* Dummy line high 8 bit */
-#define LCC6                    0x94 /* Lens correction option 6 */
-#define LCC7                    0x95 /* Lens correction option 7 */
-
-#define RSVD_96      		    0x96 /* Reserved */
-#define RSVD_97              	0x97 /* Reserved */
-#define RSVD_98      		    0x98 /* Reserved */
-#define RSVD_99              	0x99 /* Reserved */
-#define RSVD_9A      		    0x9A /* Reserved */
-#define RSVD_9B              	0x9B /* Reserved */
-#define RSVD_9C      		    0x9C /* Reserved */
-
-#define BD50ST			        0x9D /* 50 Hz banding filter value */
-#define BD60ST                  0x9E /* 60 Hz banding filter value */
-#define HAECC1                  0x9F /* Histogram-based AEC/AGC control 1 */
-#define HAECC2                  0xA0 /* Histogram-based AEC/AGC control 2 */
-
-#define RSVD_A1      		    0xA1 /* Reserved */
-
-#define SCALING_PCLK_DELAY      0xA2 /* Pixel clock delay */
-
-#define RSVD_A3      		    0xA3 /* Reserved */
-
-#define NT_CNTRL                0xA4 /*  */
-#define BD50MAX			        0xA5 /* 50 Hz banding step limit */
-#define HAECC3                  0xA6 /* Histogram-based AEC/AGC control 3  */
-#define HAECC4 	   	            0xA7 /* Histogram-based AEC/AGC control 4           */
-#define HAECC5		            0xA8 /* Histogram-based AEC/AGC control 5         */
-#define HAECC6		            0xA9 /* Histogram-based AEC/AGC control 6           */
-
-#define HAECC7		            0xAA /* Histogram-based AEC/AGC control 7           */
-#define 	HAECC_EN      	    0x80 /* Histogram-based AEC algorithm enable      */
-
-#define BD60MAX                 0xAB /* 60 Hz banding step limit */
-
-#define STR_OPT                 0xAC /* Register AC */
-#define STR_R			        0xAD /* R gain for led output frame */
-#define STR_G			        0xAE /* G gain for led output frame */
-#define STR_B			        0xAF /* B gain for led output frame */
-#define RSVD_B0      		    0xB0 /* Reserved */
-#define ABLC1			        0xB1 /* */
-#define RSVD_B2      		    0xB2 /* Reserved */
-#define THL_ST			        0xB3 /* ABLC target */
-#define THL_DLT			        0xB5 /* ABLC stable range */
-
-#define RSVD_B6      		    0xB6 /* Reserved */
-#define RSVD_B7      		    0xB7 /* Reserved */
-#define RSVD_B8      		    0xB8 /* Reserved */
-#define RSVD_B9      		    0xB9 /* Reserved */
-#define RSVD_BA      		    0xBA /* Reserved */
-#define RSVD_BB      		    0xBB /* Reserved */
-#define RSVD_BC      		    0xBC /* Reserved */
-#define RSVD_BD      	    	0xBD /* Reserved */
-
-#define AD_CHB			        0xBE /* blue channel black level compensation */
-#define AD_CHR			        0xBF /* Red channel black level compensation */
-#define AD_CHGb			        0xC0 /* Gb channel black level compensation */
-#define AD_CHGr			        0xC1 /* Gr channel black level compensation */
-
-#define RSVD_C2      		    0xC2 /* Reserved */
-#define RSVD_C3      		    0xC3 /* Reserved */
-#define RSVD_C4      		    0xC4 /* Reserved */
-#define RSVD_C5      		    0xC5 /* Reserved */
-#define RSVD_C6      		    0xC6 /* Reserved */
-#define RSVD_C7      		    0xC7 /* Reserved */
-#define RSVD_C8      		    0xC8 /* Reserved */
-
-#define SATCTR			        0xC9 /* Saturation control */
-#define SET_REG(reg, x)         (##reg_DEFAULT|x)
-
-#endif //__OV7670_REG_REGS_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov7725.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov7725.h
@@ -1,14 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV7725 driver.
- *
- */
-#ifndef __OV7725_H__
-#define __OV7725_H__
-#include "sensor.h"
-
-int ov7725_init(sensor_t *sensor);
-#endif // __OV7725_H__
--- a/code/components/esp32-camera-master/sensors/private_include/ov7725_regs.h
+++ b/code/components/esp32-camera-master/sensors/private_include/ov7725_regs.h
@@ -1,335 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * OV2640 register definitions.
- */
-#ifndef __REG_REGS_H__
-#define __REG_REGS_H__
-#define GAIN                    0x00 /* AGC – Gain control gain setting  */
-#define BLUE                    0x01 /* AWB – Blue channel gain setting  */
-#define RED                     0x02 /* AWB – Red channel gain setting   */
-#define GREEN                   0x03 /* AWB – Green channel gain setting */
-#define BAVG                    0x05 /* U/B Average Level   */
-#define GAVG                    0x06 /* Y/Gb Average Level  */
-#define RAVG                    0x07 /* V/R Average Level   */
-#define AECH                    0x08 /* Exposure Value – AEC MSBs */
-
-#define COM2                    0x09 /* Common Control 2 */
-#define COM2_SOFT_SLEEP         0x10 /* Soft sleep mode  */
-#define COM2_OUT_DRIVE_1x       0x00 /* Output drive capability 1x */
-#define COM2_OUT_DRIVE_2x       0x01 /* Output drive capability 2x */
-#define COM2_OUT_DRIVE_3x       0x02 /* Output drive capability 3x */
-#define COM2_OUT_DRIVE_4x       0x03 /* Output drive capability 4x */
-
-#define REG_PID                     0x0A /* Product ID Number MSB */
-#define REG_VER                     0x0B /* Product ID Number LSB */
-
-#define COM3                    0x0C /* Common Control 3                                        */
-#define COM3_VFLIP              0x80 /* Vertical flip image ON/OFF selection                    */
-#define COM3_MIRROR             0x40 /* Horizontal mirror image ON/OFF selection                */
-#define COM3_SWAP_BR            0x20 /* Swap B/R output sequence in RGB output mode             */
-#define COM3_SWAP_YUV           0x10 /* Swap Y/UV output sequence in YUV output mode            */
-#define COM3_SWAP_MSB           0x08 /* Swap output MSB/LSB                                     */
-#define COM3_TRI_CLOCK          0x04 /* Tri-state option for output clock at power-down period  */
-#define COM3_TRI_DATA           0x02 /* Tri-state option for output data at power-down period   */
-#define COM3_COLOR_BAR          0x01 /* Sensor color bar test pattern output enable             */
-#define COM3_SET_CBAR(r, x)     ((r&0xFE)|((x&1)<<0))
-#define COM3_SET_MIRROR(r, x)   ((r&0xBF)|((x&1)<<6))
-#define COM3_SET_FLIP(r, x)     ((r&0x7F)|((x&1)<<7))
-
-#define COM4                    0x0D /* Common Control 4         */
-#define COM4_PLL_BYPASS         0x00 /* Bypass PLL               */
-#define COM4_PLL_4x             0x40 /* PLL frequency 4x         */
-#define COM4_PLL_6x             0x80 /* PLL frequency 6x         */
-#define COM4_PLL_8x             0xc0 /* PLL frequency 8x         */
-#define COM4_AEC_FULL           0x00 /* AEC evaluate full window */
-#define COM4_AEC_1_2            0x10 /* AEC evaluate 1/2 window  */
-#define COM4_AEC_1_4            0x20 /* AEC evaluate 1/4 window  */
-#define COM4_AEC_2_3            0x30 /* AEC evaluate 2/3 window  */
-
-#define COM5                    0x0E /* Common Control 5 */
-#define COM5_AFR                0x80 /* Auto frame rate control ON/OFF selection (night mode) */
-#define COM5_AFR_SPEED          0x40 /* Auto frame rate control speed selection */
-#define COM5_AFR_0              0x00 /* No reduction of frame rate          */
-#define COM5_AFR_1_2            0x10 /* Max reduction to 1/2 frame rate     */
-#define COM5_AFR_1_4            0x20 /* Max reduction to 1/4 frame rate     */
-#define COM5_AFR_1_8            0x30 /* Max reduction to 1/8 frame rate     */
-#define COM5_AFR_4x             0x04 /* Add frame when AGC reaches 4x gain  */
-#define COM5_AFR_8x             0x08 /* Add frame when AGC reaches 8x gain  */
-#define COM5_AFR_16x            0x0c /* Add frame when AGC reaches 16x gain */
-#define COM5_AEC_NO_LIMIT       0x01 /* No limit to AEC increase step       */
-
-#define COM6                    0x0F /* Common Control 6 */
-#define COM6_AUTO_WINDOW        0x01 /* Auto window setting ON/OFF selection when format changes */
-
-#define AEC                     0x10 /* AEC[7:0] (see register AECH for AEC[15:8]) */
-#define CLKRC                   0x11 /* Internal Clock */
-
-#define COM7                    0x12 /* Common Control 7         */
-#define COM7_RESET              0x80 /* SCCB Register Reset      */
-#define COM7_RES_VGA            0x00 /* Resolution VGA           */
-#define COM7_RES_QVGA           0x40 /* Resolution QVGA          */
-#define COM7_BT656              0x20 /* BT.656 protocol ON/OFF   */
-#define COM7_SENSOR_RAW         0x10 /* Sensor RAW               */
-#define COM7_FMT_GBR422         0x00 /* RGB output format GBR422 */
-#define COM7_FMT_RGB565         0x04 /* RGB output format RGB565 */
-#define COM7_FMT_RGB555         0x08 /* RGB output format RGB555 */
-#define COM7_FMT_RGB444         0x0C /* RGB output format RGB444 */
-#define COM7_FMT_YUV            0x00 /* Output format YUV        */
-#define COM7_FMT_P_BAYER        0x01 /* Output format Processed Bayer RAW */
-#define COM7_FMT_RGB            0x02 /* Output format RGB        */
-#define COM7_FMT_R_BAYER        0x03 /* Output format Bayer RAW  */
-#define COM7_SET_FMT(r, x)      ((r&0xFC)|((x&0x3)<<0))
-#define COM7_SET_RGB(r, x)      ((r&0xF0)|(x&0x0C)|COM7_FMT_RGB)
-
-#define COM8                    0x13 /* Common Control 8                */
-#define COM8_FAST_AUTO          0x80 /* Enable fast AGC/AEC algorithm   */
-#define COM8_STEP_VSYNC         0x00 /* AEC - Step size limited to vertical blank */
-#define COM8_STEP_UNLIMIT       0x40 /* AEC - Step size unlimited step size       */
-#define COM8_BANDF_EN           0x20 /* Banding filter ON/OFF */
-#define COM8_AEC_BANDF          0x10 /* Enable AEC below banding value */
-#define COM8_AEC_FINE_EN        0x08 /* Fine AEC ON/OFF control */
-#define COM8_AGC_EN             0x04 /* AGC Enable */
-#define COM8_AWB_EN             0x02 /* AWB Enable */
-#define COM8_AEC_EN             0x01 /* AEC Enable */
-#define COM8_SET_AGC(r, x)      ((r&0xFB)|((x&0x1)<<2))
-#define COM8_SET_AWB(r, x)      ((r&0xFD)|((x&0x1)<<1))
-#define COM8_SET_AEC(r, x)      ((r&0xFE)|((x&0x1)<<0))
-
-#define COM9                    0x14 /* Common Control 9 */
-#define COM9_HISTO_AVG          0x80 /* Histogram or average based AEC/AGC selection */
-#define COM9_AGC_GAIN_2x        0x00 /* Automatic Gain Ceiling 2x  */
-#define COM9_AGC_GAIN_4x        0x10 /* Automatic Gain Ceiling 4x  */
-#define COM9_AGC_GAIN_8x        0x20 /* Automatic Gain Ceiling 8x  */
-#define COM9_AGC_GAIN_16x       0x30 /* Automatic Gain Ceiling 16x */
-#define COM9_AGC_GAIN_32x       0x40 /* Automatic Gain Ceiling 32x */
-#define COM9_DROP_VSYNC         0x04 /* Drop VSYNC output of corrupt frame */
-#define COM9_DROP_HREF          0x02 /* Drop HREF output of corrupt frame  */
-#define COM9_SET_AGC(r, x)      ((r&0x8F)|((x&0x07)<<4))
-
-#define COM10                   0x15 /* Common Control 10 */
-#define COM10_NEGATIVE          0x80 /* Output negative data */
-#define COM10_HSYNC_EN          0x40 /* HREF changes to HSYNC */
-#define COM10_PCLK_FREE         0x00 /* PCLK output option: free running PCLK */
-#define COM10_PCLK_MASK         0x20 /* PCLK output option: masked during horizontal blank  */
-#define COM10_PCLK_REV          0x10 /* PCLK reverse */
-#define COM10_HREF_REV          0x08 /* HREF reverse */
-#define COM10_VSYNC_FALLING     0x00 /* VSYNC changes on falling edge of PCLK */
-#define COM10_VSYNC_RISING      0x04 /* VSYNC changes on rising edge of PCLK */
-#define COM10_VSYNC_NEG         0x02 /* VSYNC negative */
-#define COM10_OUT_RANGE_8       0x01 /* Output data range: Full range */
-#define COM10_OUT_RANGE_10      0x00 /* Output data range: Data from [10] to [F0] (8 MSBs) */
-
-#define REG16                   0x16 /* Register 16 */
-#define REG16_BIT_SHIFT         0x80 /* Bit shift test pattern options */
-#define HSTART                  0x17 /* Horizontal Frame (HREF column) Start 8 MSBs (2 LSBs are at HREF[5:4]) */
-#define HSIZE                   0x18 /* Horizontal Sensor Size (2 LSBs are at HREF[1:0]) */
-#define VSTART                  0x19 /* Vertical Frame (row) Start 8 MSBs (1 LSB is at HREF[6]) */
-#define VSIZE                   0x1A /* Vertical Sensor Size (1 LSB is at HREF[2]) */
-#define PSHFT                   0x1B /* Data Format - Pixel Delay Select */
-#define REG_MIDH                    0x1C /* Manufacturer ID Byte – High */
-#define REG_MIDL                    0x1D /* Manufacturer ID Byte – Low */
-#define LAEC                    0x1F /* Fine AEC Value - defines exposure value less than one row period */
-
-#define COM11                   0x20 /* Common Control 11 */
-#define COM11_SNGL_FRAME_EN     0x02 /* Single frame ON/OFF selection */
-#define COM11_SNGL_XFR_TRIG     0x01 /* Single frame transfer trigger */
-
-#define BDBASE                  0x22 /* Banding Filter Minimum AEC Value */
-#define DBSTEP                  0x23 /* Banding Filter Maximum Step */
-#define AEW                     0x24 /* AGC/AEC - Stable Operating Region (Upper Limit) */
-#define AEB                     0x25 /* AGC/AEC - Stable Operating Region (Lower Limit) */
-#define VPT                     0x26 /* AGC/AEC Fast Mode Operating Region */
-#define REG28                   0x28 /* Selection on the number of dummy rows, N */
-#define HOUTSIZE                0x29 /* Horizontal Data Output Size MSBs (2 LSBs at register EXHCH[1:0]) */
-#define EXHCH                   0x2A /* Dummy Pixel Insert MSB */
-#define EXHCL                   0x2B /* Dummy Pixel Insert LSB */
-#define VOUTSIZE                0x2C /* Vertical Data Output Size MSBs (LSB at register EXHCH[2])       */
-#define ADVFL                   0x2D /* LSB of Insert Dummy Rows in Vertical Sync (1 bit equals 1 row)  */
-#define ADVFH                   0x2E /* MSB of Insert Dummy Rows in Vertical Sync */
-#define YAVE                    0x2F /* Y/G Channel Average Value */
-#define LUMHTH                  0x30 /* Histogram AEC/AGC Luminance High Level Threshold */
-#define LUMLTH                  0x31 /* Histogram AEC/AGC Luminance Low Level Threshold  */
-#define HREF                    0x32 /* Image Start and Size Control */
-#define DM_LNL                  0x33 /* Dummy Row Low 8 Bits  */
-#define DM_LNH                  0x34 /* Dummy Row High 8 Bits */
-#define ADOFF_B                 0x35 /* AD Offset Compensation Value for B Channel  */
-#define ADOFF_R                 0x36 /* AD Offset Compensation Value for R Channel  */
-#define ADOFF_GB                0x37 /* AD Offset Compensation Value for GB Channel */
-#define ADOFF_GR                0x38 /* AD Offset Compensation Value for GR Channel */
-#define OFF_B                   0x39 /* AD Offset Compensation Value for B Channel  */
-#define OFF_R                   0x3A /* AD Offset Compensation Value for R Channel  */
-#define OFF_GB                  0x3B /* AD Offset Compensation Value for GB Channel */
-#define OFF_GR                  0x3C /* AD Offset Compensation Value for GR Channel */
-#define COM12                   0x3D /* DC offset compensation for analog process */
-
-#define COM13                   0x3E /* Common Control 13 */
-#define COM13_BLC_EN            0x80 /* BLC enable */
-#define COM13_ADC_EN            0x40 /* ADC channel BLC ON/OFF control */
-#define COM13_ANALOG_BLC        0x20 /* Analog processing channel BLC ON/OFF control */
-#define COM13_ABLC_GAIN_EN      0x04 /* ABLC gain trigger enable */
-
-#define COM14                   0x3F /* Common Control 14 */
-#define COM15                   0x40 /* Common Control 15 */
-#define COM16                   0x41 /* Common Control 16 */
-#define TGT_B                   0x42 /* BLC Blue Channel Target Value   */
-#define TGT_R                   0x43 /* BLC Red Channel Target Value    */
-#define TGT_GB                  0x44 /* BLC Gb Channel Target Value     */
-#define TGT_GR                  0x45 /* BLC Gr Channel Target Value     */
-
-#define LC_CTR                  0x46 /* Lens Correction Control */
-#define LC_CTR_RGB_COMP_1       0x00 /* R, G, and B channel compensation coefficient is set by LC_COEF (0x49) */
-#define LC_CTR_RGB_COMP_3       0x04 /* R, G, and B channel compensation coefficient is set by registers
-                                        LC_COEFB (0x4B), LC_COEF (0x49), and LC_COEFR (0x4C), respectively */
-#define LC_CTR_EN               0x01 /* Lens correction enable */
-#define LC_XC                   0x47 /* X Coordinate of Lens Correction Center Relative to Array Center */
-#define LC_YC                   0x48 /* Y Coordinate of Lens Correction Center Relative to Array Center */
-#define LC_COEF                 0x49 /* Lens Correction Coefficient */
-#define LC_RADI                 0x4A /* Lens Correction Radius */
-#define LC_COEFB                0x4B /* Lens Correction B Channel Compensation Coefficient */
-#define LC_COEFR                0x4C /* Lens Correction R Channel Compensation Coefficient */
-
-#define FIXGAIN                 0x4D /* Analog Fix Gain Amplifier */
-#define AREF0                   0x4E /* Sensor Reference Control */
-#define AREF1                   0x4F /* Sensor Reference Current Control */
-#define AREF2                   0x50 /* Analog Reference Control */
-#define AREF3                   0x51 /* ADC Reference Control */
-#define AREF4                   0x52 /* ADC Reference Control */
-#define AREF5                   0x53 /* ADC Reference Control */
-#define AREF6                   0x54 /* Analog Reference Control */
-#define AREF7                   0x55 /* Analog Reference Control */
-#define UFIX                    0x60 /* U Channel Fixed Value Output */
-#define VFIX                    0x61 /* V Channel Fixed Value Output */
-#define AWBB_BLK                0x62 /* AWB Option for Advanced AWB  */
-
-#define AWB_CTRL0               0x63 /* AWB Control Byte 0   */
-#define AWB_CTRL0_GAIN_EN       0x80 /* AWB gain enable      */
-#define AWB_CTRL0_CALC_EN       0x40 /* AWB calculate enable */
-#define AWB_CTRL0_WBC_MASK      0x0F /* WBC threshold 2      */
-
-#define DSP_CTRL1               0x64 /* DSP Control Byte 1                  */
-#define DSP_CTRL1_FIFO_EN       0x80 /* FIFO enable/disable selection       */
-#define DSP_CTRL1_UV_EN         0x40 /* UV adjust function ON/OFF selection */
-#define DSP_CTRL1_SDE_EN        0x20 /* SDE enable                          */
-#define DSP_CTRL1_MTRX_EN       0x10 /* Color matrix ON/OFF selection       */
-#define DSP_CTRL1_INTRP_EN      0x08 /* Interpolation ON/OFF selection      */
-#define DSP_CTRL1_GAMMA_EN      0x04 /* Gamma function ON/OFF selection     */
-#define DSP_CTRL1_BLACK_EN      0x02 /* Black defect auto correction ON/OFF */
-#define DSP_CTRL1_WHITE_EN      0x01 /* White defect auto correction ON/OFF */
-
-#define DSP_CTRL2               0x65 /* DSP Control Byte 2          */
-#define DSP_CTRL2_VDCW_EN       0x08 /* Vertical DCW enable         */
-#define DSP_CTRL2_HDCW_EN       0x04 /* Horizontal DCW enable       */
-#define DSP_CTRL2_VZOOM_EN      0x02 /* Vertical zoom out enable    */
-#define DSP_CTRL2_HZOOM_EN      0x01 /* Horizontal zoom out enable  */
-
-#define DSP_CTRL3               0x66 /* DSP Control Byte 3                      */
-#define DSP_CTRL3_UV_EN         0x80 /* UV output sequence option               */
-#define DSP_CTRL3_CBAR_EN       0x20 /* DSP color bar ON/OFF selection          */
-#define DSP_CTRL3_FIFO_EN       0x08 /* FIFO power down ON/OFF selection        */
-#define DSP_CTRL3_SCAL1_PWDN    0x04 /* Scaling module power down control 1     */
-#define DSP_CTRL3_SCAL2_PWDN    0x02 /* Scaling module power down control 2     */
-#define DSP_CTRL3_INTRP_PWDN    0x01 /* Interpolation module power down control */
-#define DSP_CTRL3_SET_CBAR(r, x)    ((r&0xDF)|((x&1)<<5))
-
-
-#define DSP_CTRL4               0x67 /* DSP Control Byte 4          */
-#define DSP_CTRL4_YUV_RGB       0x00 /* Output selection YUV or RGB */
-#define DSP_CTRL4_RAW8          0x02 /* Output selection RAW8       */
-#define DSP_CTRL4_RAW10         0x03 /* Output selection RAW10      */
-
-
-#define AWB_BIAS                0x68 /* AWB BLC Level Clip */
-#define AWB_CTRL1               0x69 /* AWB Control 1 */
-#define AWB_CTRL2               0x6A /* AWB Control 2 */
-
-#define AWB_CTRL3               0x6B /* AWB Control 3 */
-#define AWB_CTRL3_ADVANCED      0x80 /* AWB mode select - Advanced AWB */
-#define AWB_CTRL3_SIMPLE        0x00 /* AWB mode select - Simple AWB */
-
-#define AWB_CTRL4               0x6C /* AWB Control 4  */
-#define AWB_CTRL5               0x6D /* AWB Control 5  */
-#define AWB_CTRL6               0x6E /* AWB Control 6  */
-#define AWB_CTRL7               0x6F /* AWB Control 7  */
-#define AWB_CTRL8               0x70 /* AWB Control 8  */
-#define AWB_CTRL9               0x71 /* AWB Control 9  */
-#define AWB_CTRL10              0x72 /* AWB Control 10 */
-#define AWB_CTRL11              0x73 /* AWB Control 11 */
-#define AWB_CTRL12              0x74 /* AWB Control 12 */
-#define AWB_CTRL13              0x75 /* AWB Control 13 */
-#define AWB_CTRL14              0x76 /* AWB Control 14 */
-#define AWB_CTRL15              0x77 /* AWB Control 15 */
-#define AWB_CTRL16              0x78 /* AWB Control 16 */
-#define AWB_CTRL17              0x79 /* AWB Control 17 */
-#define AWB_CTRL18              0x7A /* AWB Control 18 */
-#define AWB_CTRL19              0x7B /* AWB Control 19 */
-#define AWB_CTRL20              0x7C /* AWB Control 20 */
-#define AWB_CTRL21              0x7D /* AWB Control 21 */
-#define GAM1                    0x7E /* Gamma Curve 1st Segment Input End Point 0x04 Output Value */
-#define GAM2                    0x7F /* Gamma Curve 2nd Segment Input End Point 0x08 Output Value */
-#define GAM3                    0x80 /* Gamma Curve 3rd Segment Input End Point 0x10 Output Value */
-#define GAM4                    0x81 /* Gamma Curve 4th Segment Input End Point 0x20 Output Value */
-#define GAM5                    0x82 /* Gamma Curve 5th Segment Input End Point 0x28 Output Value */
-#define GAM6                    0x83 /* Gamma Curve 6th Segment Input End Point 0x30 Output Value */
-#define GAM7                    0x84 /* Gamma Curve 7th Segment Input End Point 0x38 Output Value */
-#define GAM8                    0x85 /* Gamma Curve 8th Segment Input End Point 0x40 Output Value */
-#define GAM9                    0x86 /* Gamma Curve 9th Segment Input End Point 0x48 Output Value */
-#define GAM10                   0x87 /* Gamma Curve 10th Segment Input End Point 0x50 Output Value */
-#define GAM11                   0x88 /* Gamma Curve 11th Segment Input End Point 0x60 Output Value */
-#define GAM12                   0x89 /* Gamma Curve 12th Segment Input End Point 0x70 Output Value */
-#define GAM13                   0x8A /* Gamma Curve 13th Segment Input End Point 0x90 Output Value */
-#define GAM14                   0x8B /* Gamma Curve 14th Segment Input End Point 0xB0 Output Value */
-#define GAM15                   0x8C /* Gamma Curve 15th Segment Input End Point 0xD0 Output Value */
-#define SLOP                    0x8D /* Gamma Curve Highest Segment Slope */
-#define DNSTH                   0x8E /* De-noise Threshold */
-#define EDGE0                   0x8F /* Edge Enhancement Strength Control */
-#define EDGE1                   0x90 /* Edge Enhancement Threshold Control */
-#define DNSOFF                  0x91 /* Auto De-noise Threshold Control */
-#define EDGE2                   0x92 /* Edge Enhancement Strength Upper Limit */
-#define EDGE3                   0x93 /* Edge Enhancement Strength Upper Limit */
-#define MTX1                    0x94 /* Matrix Coefficient 1 */
-#define MTX2                    0x95 /* Matrix Coefficient 2 */
-#define MTX3                    0x96 /* Matrix Coefficient 3 */
-#define MTX4                    0x97 /* Matrix Coefficient 4 */
-#define MTX5                    0x98 /* Matrix Coefficient 5 */
-#define MTX6                    0x99 /* Matrix Coefficient 6 */
-
-#define MTX_CTRL                0x9A /* Matrix Control */
-#define MTX_CTRL_DBL_EN         0x80 /* Matrix double ON/OFF selection */
-
-#define BRIGHTNESS              0x9B /* Brightness Control */
-#define CONTRAST                0x9C /* Contrast Gain */
-#define UVADJ0                  0x9E /* Auto UV Adjust Control 0 */
-#define UVADJ1                  0x9F /* Auto UV Adjust Control 1 */
-#define SCAL0                   0xA0 /* DCW Ratio Control */
-#define SCAL1                   0xA1 /* Horizontal Zoom Out Control */
-#define SCAL2                   0xA2 /* Vertical Zoom Out Control */
-#define FIFODLYM                0xA3 /* FIFO Manual Mode Delay Control */
-#define FIFODLYA                0xA4 /* FIFO Auto Mode Delay Control */
-
-#define SDE                     0xA6 /* Special Digital Effect Control  */
-#define SDE_NEGATIVE_EN         0x40 /* Negative image enable           */
-#define SDE_GRAYSCALE_EN        0x20 /* Gray scale image enable         */
-#define SDE_V_FIXED_EN          0x10 /* V fixed value enable            */
-#define SDE_U_FIXED_EN          0x08 /* U fixed value enable            */
-#define SDE_CONT_BRIGHT_EN      0x04 /* Contrast/Brightness enable      */
-#define SDE_SATURATION_EN       0x02 /* Saturation enable               */
-#define SDE_HUE_EN              0x01 /* Hue enable                      */
-
-#define USAT                    0xA7 /* U Component Saturation Gain     */
-#define VSAT                    0xA8 /* V Component Saturation Gain     */
-#define HUECOS                  0xA9 /* Cosine value × 0x80             */
-#define HUESIN                  0xAA /* Sine value × 0x80               */
-#define SIGN_BIT                0xAB /* Sign Bit for Hue and Brightness */
-
-#define DSPAUTO                 0xAC /* DSP Auto Function ON/OFF Control */
-#define DSPAUTO_AWB_EN          0x80 /* AWB auto threshold control */
-#define DSPAUTO_DENOISE_EN      0x40 /* De-noise auto threshold control */
-#define DSPAUTO_EDGE_EN         0x20 /* Sharpness (edge enhancement) auto strength control */
-#define DSPAUTO_UV_EN           0x10 /* UV adjust auto slope control */
-#define DSPAUTO_SCAL0_EN        0x08 /* Auto scaling factor control (register SCAL0 (0xA0)) */
-#define DSPAUTO_SCAL1_EN        0x04 /* Auto scaling factor control (registers SCAL1 (0xA1 and SCAL2 (0xA2))*/
-#define SET_REG(reg, x)         (##reg_DEFAULT|x)
-#endif //__REG_REGS_H__
--- a/code/components/jomjol_configfile/configFile.cpp
+++ b/code/components/jomjol_configfile/configFile.cpp
@@ -4,13 +4,16 @@

 #include "Helper.h"
 #include "configFile.h"
+#include <esp_log.h>

-//static const char *TAGCONFIGFILE = "configFile";
+#include "../../include/defines.h"
+
+static const char *TAG = "CONFIG";

 ConfigFile::ConfigFile(std::string filePath)
 {
    std::string config = FormatFileName(filePath);
-    pFile = OpenFileAndWait(config.c_str(), "r");
+    pFile = fopen(config.c_str(), "r");
 }

 ConfigFile::~ConfigFile()
@@ -48,7 +51,7 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)

 	if (fgets(zw, 1024, pFile))
 	{
-		printf("%s", zw);
+		ESP_LOGD(TAG, "%s", zw);
 		if ((strlen(zw) == 0) && feof(pFile))
 		{
 			*rt = "";
@@ -64,10 +67,10 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)
 	}
 	*rt = zw;
 	*rt = trim(*rt);
-	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))			// Kommentarzeilen (; oder #) und Leerzeilen überspringen, es sei denn es ist ein neuer auskommentierter Paragraph
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))
 	{
 		fgets(zw, 1024, pFile);
-		printf("%s", zw);		
+		ESP_LOGD(TAG, "%s", zw);
 		if (feof(pFile))
 		{
 			*rt = "";
@@ -81,25 +84,3 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)
    disabled = ((*rt)[0] == ';');
 	return true;
 }
-
-std::vector<string> ConfigFile::ZerlegeZeile(std::string input, std::string delimiter)
-{
-	std::vector<string> Output;
-//	std::string delimiter = " =,";
-
-	input = trim(input, delimiter);
-	size_t pos = findDelimiterPos(input, delimiter);
-	std::string token;
-	while (pos != std::string::npos) {
-		token = input.substr(0, pos);
-		token = trim(token, delimiter);
-		Output.push_back(token);
-		input.erase(0, pos + 1);
-		input = trim(input, delimiter);
-		pos = findDelimiterPos(input, delimiter);
-	}
-	Output.push_back(input);
-
-	return Output;
-
-}
--- a/code/components/jomjol_configfile/configFile.h
+++ b/code/components/jomjol_configfile/configFile.h
@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef CONFIGFILE_H
+#define CONFIGFILE_H
+
 #include <string>
 #include <vector>

@@ -9,8 +14,10 @@ public:
    bool isNewParagraph(std::string input);
    bool GetNextParagraph(std::string& aktparamgraph, bool &disabled, bool &eof);
 	bool getNextLine(std::string* rt, bool &disabled, bool &eof);
-    std::vector<std::string> ZerlegeZeile(std::string input, std::string delimiter = " =, \t");
+    bool ConfigFileExists(){return pFile;};
    
 private:
    FILE* pFile;
-};
+};
+
+#endif //CONFIGFILE_H
--- a/code/components/jomjol_controlGPIO/Color.h
+++ b/code/components/jomjol_controlGPIO/Color.h
@@ -1,5 +1,8 @@
 #pragma once

+#ifndef COLOR_H
+#define COLOR_H
+
 #include <cstdint>
 #include "esp_attr.h"
 union Hsv;
@@ -67,3 +70,5 @@ union Hsv {
    bool operator==( Hsv in ) const { return in.value == value; }
    void swap( Hsv& o ) { value = o.value; }
 };
+
+#endif //COLOR_H
--- a/code/components/jomjol_controlGPIO/SmartLeds.cpp
+++ b/code/components/jomjol_controlGPIO/SmartLeds.cpp
@@ -1,5 +1,32 @@
 #include "SmartLeds.h"

+
+/* PlatformIO 6 (ESP IDF 5) does no longer allow access to RMTMEM,
+   see https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html?highlight=rmtmem#id5 
+   As a dirty workaround, we copy the needed structures from rmt_struct.h
+   In the long run, this should be replaced! */
+typedef struct rmt_item32_s {
+    union {
+        struct {
+            uint32_t duration0 :15;
+            uint32_t level0 :1;
+            uint32_t duration1 :15;
+            uint32_t level1 :1;
+        };
+        uint32_t val;
+    };
+} rmt_item32_t;
+
+//Allow access to RMT memory using RMTMEM.chan[0].data32[8]
+typedef volatile struct rmt_mem_s {
+    struct {
+        rmt_item32_t data32[64];
+    } chan[8];
+} rmt_mem_t;
+extern rmt_mem_t RMTMEM;
+
+
+
 IsrCore SmartLed::_interruptCore = CoreCurrent;
 intr_handle_t SmartLed::_interruptHandle = NULL;

--- a/code/components/jomjol_controlGPIO/SmartLeds.h
+++ b/code/components/jomjol_controlGPIO/SmartLeds.h
@@ -1,5 +1,8 @@
 #pragma once

+#ifndef SMARTLEDS_H
+#define SMARTLEDS_H
+
 /*
 * A C++ driver for the WS2812 LEDs using the RMT peripheral on the ESP32.
 *
@@ -32,6 +35,20 @@
 #include <cassert>
 #include <cstring>

+#include "esp_idf_version.h"
+#if (ESP_IDF_VERSION_MAJOR >= 5)
+#include "soc/periph_defs.h"
+#include "esp_private/periph_ctrl.h"
+#include "soc/gpio_sig_map.h"
+#include "soc/gpio_periph.h"
+#include "soc/io_mux_reg.h"
+#include "esp_rom_gpio.h"
+#define gpio_pad_select_gpio esp_rom_gpio_pad_select_gpio
+#define gpio_matrix_in(a,b,c) esp_rom_gpio_connect_in_signal(a,b,c)
+#define gpio_matrix_out(a,b,c,d) esp_rom_gpio_connect_out_signal(a,b,c,d)
+#define ets_delay_us(a) esp_rom_delay_us(a)
+#endif
+
 #if defined ( ARDUINO )
    extern "C" { // ...someone forgot to put in the includes...
        #include "esp32-hal.h"
@@ -62,6 +79,27 @@
    #include <stdio.h>
 #endif

+#if (ESP_IDF_VERSION_MAJOR >= 4) && (ESP_IDF_VERSION_MINOR > 1)
+#include "hal/gpio_ll.h"
+#else
+#include "soc/gpio_periph.h"
+#define esp_rom_delay_us ets_delay_us
+static inline int gpio_ll_get_level(gpio_dev_t *hw, int gpio_num)
+{
+    if (gpio_num < 32) {
+        return (hw->in >> gpio_num) & 0x1;
+    } else {
+        return (hw->in1.data >> (gpio_num - 32)) & 0x1;
+    }
+}
+#endif
+
+#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0))
+#if !(configENABLE_BACKWARD_COMPATIBILITY == 1)
+#define xSemaphoreHandle SemaphoreHandle_t
+#endif
+#endif
+
 #include "Color.h"

 namespace detail {
@@ -528,3 +566,5 @@ private:
    int _latchFrames;
    uint8_t _latchBuffer[ LATCH_FRAME_SIZE_BYTES ];
 };
+
+#endif //SMARTLEDS_H
--- a/code/components/jomjol_controlGPIO/server_GPIO.cpp
+++ b/code/components/jomjol_controlGPIO/server_GPIO.cpp
@@ -6,32 +6,29 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_system.h"
-#include "esp_event.h"

-#include "server_tflite.h"
-
-//#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
 #include "esp_log.h"
-//#include "errno.h"

 #include <sys/stat.h>
 #include <vector>
-//#include <regex>

-#include "defines.h"
+#include "../../include/defines.h"

 #include "server_GPIO.h"

 #include "ClassLogFile.h"
 #include "configFile.h"
 #include "Helper.h"
+
+#ifdef ENABLE_MQTT
 #include "interface_mqtt.h"
+#include "server_mqtt.h"
+#endif //ENABLE_MQTT

-static const char *TAG_SERVERGPIO = "server_GPIO";
+
+static const char *TAG = "GPIO";
 QueueHandle_t gpio_queue_handle = NULL;

-#define DEBUG_DETAIL_ON 
-
 GpioPin::GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_int_type_t interruptType, uint8_t dutyResolution, std::string mqttTopic, bool httpEnable) 
 {
    _gpio = gpio;
@@ -43,7 +40,7 @@ GpioPin::GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_i

 GpioPin::~GpioPin()
 {
-    ESP_LOGD(TAG_SERVERGPIO,"reset GPIO pin %d", _gpio);
+    ESP_LOGD(TAG,"reset GPIO pin %d", _gpio);
    if (_interruptType != GPIO_INTR_DISABLE) {
        //hook isr handler for specific gpio pin
        gpio_isr_handler_remove(_gpio);
@@ -66,13 +63,13 @@ static void IRAM_ATTR gpio_isr_handler(void* arg)
 }

 static void gpioHandlerTask(void *arg) {
-    ESP_LOGD(TAG_SERVERGPIO,"start interrupt task");
+    ESP_LOGD(TAG,"start interrupt task");
    while(1){
        if(uxQueueMessagesWaiting(gpio_queue_handle)){
            while(uxQueueMessagesWaiting(gpio_queue_handle)){
                GpioResult gpioResult;
                xQueueReceive(gpio_queue_handle,(void*)&gpioResult,10);
-                ESP_LOGD(TAG_SERVERGPIO,"gpio: %d state: %d", gpioResult.gpio, gpioResult.value);
+                ESP_LOGD(TAG,"gpio: %d state: %d", gpioResult.gpio, gpioResult.value);
                ((GpioHandler*)arg)->gpioInterrupt(&gpioResult);
            }  
        }
@@ -83,12 +80,14 @@ static void gpioHandlerTask(void *arg) {
 }

 void GpioPin::gpioInterrupt(int value) {
-    if (_mqttTopic != "") {
-        ESP_LOGD(TAG_SERVERGPIO, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);
+#ifdef ENABLE_MQTT    
+    if (_mqttTopic.compare("") != 0) {
+        ESP_LOGD(TAG, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);

-        MQTTPublish(_mqttTopic, value ? "true" : "false");
-        currentState = value;
+        MQTTPublish(_mqttTopic, value ? "true" : "false", 1);        
    }
+#endif //ENABLE_MQTT
+    currentState = value;
 }

 void GpioPin::init()
@@ -110,14 +109,16 @@ void GpioPin::init()
 //    if (_interruptType != GPIO_INTR_DISABLE) {                // ohne GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X, wenn das genutzt wird, dann soll auch der Handler hier nicht initialisiert werden, da das dann über SmartLED erfolgt.
    if ((_interruptType != GPIO_INTR_DISABLE) && (_interruptType != GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X)) {
        //hook isr handler for specific gpio pin
-        ESP_LOGD(TAG_SERVERGPIO, "GpioPin::init add isr handler for GPIO %d\r\n", _gpio);
+        ESP_LOGD(TAG, "GpioPin::init add isr handler for GPIO %d", _gpio);
        gpio_isr_handler_add(_gpio, gpio_isr_handler, (void*)&_gpio);
    }

-    if ((_mqttTopic != "") && ((_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_OUTPUT_PWM) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED))) {
+#ifdef ENABLE_MQTT
+    if ((_mqttTopic.compare("") != 0) && ((_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_OUTPUT_PWM) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED))) {
        std::function<bool(std::string, char*, int)> f = std::bind(&GpioPin::handleMQTT, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        MQTTregisterSubscribeFunction(_mqttTopic, f);
    }
+#endif //ENABLE_MQTT
 }

 bool GpioPin::getValue(std::string* errorText)
@@ -131,30 +132,36 @@ bool GpioPin::getValue(std::string* errorText)

 void GpioPin::setValue(bool value, gpio_set_source setSource, std::string* errorText)
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioPin::setValue %d\r\n", value);
+    ESP_LOGD(TAG, "GpioPin::setValue %d", value);

    if ((_mode != GPIO_PIN_MODE_OUTPUT) && (_mode != GPIO_PIN_MODE_OUTPUT_PWM) && (_mode != GPIO_PIN_MODE_BUILT_IN_FLASH_LED)) {
        (*errorText) = "GPIO is not in output mode";
    } else {
        gpio_set_level(_gpio, value);

-        if ((_mqttTopic != "") && (setSource != GPIO_SET_SOURCE_MQTT)) {
-            MQTTPublish(_mqttTopic, value ? "true" : "false");
+#ifdef ENABLE_MQTT
+        if ((_mqttTopic.compare("") != 0) && (setSource != GPIO_SET_SOURCE_MQTT)) {
+            MQTTPublish(_mqttTopic, value ? "true" : "false", 1);
        }
+#endif //ENABLE_MQTT
    }
 }

 void GpioPin::publishState() {
    int newState = gpio_get_level(_gpio);
    if (newState != currentState) {
-        ESP_LOGD(TAG_SERVERGPIO,"publish state of GPIO %d new state %d", _gpio, newState);
-        MQTTPublish(_mqttTopic, newState ? "true" : "false");
+        ESP_LOGD(TAG,"publish state of GPIO %d new state %d", _gpio, newState);
+#ifdef ENABLE_MQTT
+    if (_mqttTopic.compare("") != 0)
+        MQTTPublish(_mqttTopic, newState ? "true" : "false", 1);
+#endif //ENABLE_MQTT
        currentState = newState;
    }
 }

+#ifdef ENABLE_MQTT
 bool GpioPin::handleMQTT(std::string, char* data, int data_len) {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioPin::handleMQTT data %.*s\r\n", data_len, data);
+    ESP_LOGD(TAG, "GpioPin::handleMQTT data %.*s", data_len, data);

    std::string dataStr(data, data_len);
    dataStr = toLower(dataStr);
@@ -169,16 +176,16 @@ bool GpioPin::handleMQTT(std::string, char* data, int data_len) {
    }

    if (errorText != "") {
-        ESP_LOGE(TAG_SERVERGPIO, "%s", errorText.c_str());
+        ESP_LOGE(TAG, "%s", errorText.c_str());
    }

    return (errorText == "");
 }
-
+#endif //ENABLE_MQTT

 esp_err_t callHandleHttpRequest(httpd_req_t *req)
 {
-    ESP_LOGD(TAG_SERVERGPIO,"callHandleHttpRequest");
+    ESP_LOGD(TAG,"callHandleHttpRequest");

    GpioHandler *gpioHandler = (GpioHandler*)req->user_ctx;
    return gpioHandler->handleHttpRequest(req);
@@ -186,17 +193,17 @@ esp_err_t callHandleHttpRequest(httpd_req_t *req)

 void taskGpioHandler(void *pvParameter)
 {
-    ESP_LOGD(TAG_SERVERGPIO,"taskGpioHandler");
+    ESP_LOGD(TAG,"taskGpioHandler");
    ((GpioHandler*)pvParameter)->init();
 }

 GpioHandler::GpioHandler(std::string configFile, httpd_handle_t httpServer) 
 {
-    ESP_LOGI(TAG_SERVERGPIO,"start GpioHandler");
+    ESP_LOGI(TAG,"start GpioHandler");
    _configFile = configFile;
    _httpServer = httpServer;

-    ESP_LOGI(TAG_SERVERGPIO, "register GPIO Uri");
+    ESP_LOGI(TAG, "register GPIO Uri");
    registerGpioUri();
 }

@@ -210,10 +217,10 @@ GpioHandler::~GpioHandler()  {
 void GpioHandler::init()
 {
    // TickType_t xDelay = 60000 / portTICK_PERIOD_MS;
-    // printf("wait before start %ldms\r\n", (long) xDelay);
+    // ESP_LOGD(TAG, "wait before start %ldms", (long) xDelay);
    // vTaskDelay( xDelay );

-    printf("*************** Start GPIOHandler_Init *****************\n");
+    ESP_LOGD(TAG, "*************** Start GPIOHandler_Init *****************");

    if (gpioMap == NULL) {
        gpioMap = new std::map<gpio_num_t, GpioPin*>();
@@ -222,12 +229,12 @@ void GpioHandler::init()
    }
    
    
-    ESP_LOGI(TAG_SERVERGPIO, "read GPIO config and init GPIO");
+    ESP_LOGI(TAG, "read GPIO config and init GPIO");
    if (!readConfig()) {
        clear();
        delete gpioMap;
        gpioMap = NULL;
-        ESP_LOGI(TAG_SERVERGPIO, "GPIO init comleted, handler is disabled");
+        ESP_LOGI(TAG, "GPIO init completed, handler is disabled");
        return;
    }

@@ -236,20 +243,22 @@ void GpioHandler::init()
        it->second->init();
    }

+#ifdef ENABLE_MQTT
    std::function<void()> f = std::bind(&GpioHandler::handleMQTTconnect, this);
    MQTTregisterConnectFunction("gpio-handler", f);
+#endif //ENABLE_MQTT

    if (xHandleTaskGpio == NULL) {
        gpio_queue_handle = xQueueCreate(10,sizeof(GpioResult));
-        BaseType_t  xReturned = xTaskCreate(&gpioHandlerTask, "gpio_int", configMINIMAL_STACK_SIZE * 8, (void *)this, tskIDLE_PRIORITY + 2, &xHandleTaskGpio);
+        BaseType_t  xReturned = xTaskCreate(&gpioHandlerTask, "gpio_int", 3 * 1024, (void *)this, tskIDLE_PRIORITY + 4, &xHandleTaskGpio);
        if(xReturned == pdPASS ) {
-            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler started");
+            ESP_LOGD(TAG, "xHandletaskGpioHandler started");
        } else {
-            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
+            ESP_LOGD(TAG, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
        }
    }

-    ESP_LOGI(TAG_SERVERGPIO, "GPIO init comleted, is enabled");
+    ESP_LOGI(TAG, "GPIO init completed, is enabled");
 }

 void GpioHandler::taskHandler() {
@@ -261,7 +270,7 @@ void GpioHandler::taskHandler() {
    }
 }

-
+#ifdef ENABLE_MQTT
 void GpioHandler::handleMQTTconnect()
 {
    if (gpioMap != NULL) {
@@ -271,9 +280,12 @@ void GpioHandler::handleMQTTconnect()
        }
    }
 }
+#endif //ENABLE_MQTT

 void GpioHandler::deinit() {
+#ifdef ENABLE_MQTT
    MQTTunregisterConnectFunction("gpio-handler");
+#endif //ENABLE_MQTT
    clear();
    if (xHandleTaskGpio != NULL) {
        vTaskDelete(xHandleTaskGpio);
@@ -294,19 +306,19 @@ bool GpioHandler::readConfig()

    ConfigFile configFile = ConfigFile(_configFile); 

-    std::vector<std::string> zerlegt;
+    std::vector<std::string> splitted;
    std::string line = "";
    bool disabledLine = false;
    bool eof = false;
    gpio_num_t gpioExtLED = (gpio_num_t) 0;
    
-//    printf("readConfig - Start 1\n");
+//    ESP_LOGD(TAG, "readConfig - Start 1");
        
    while ((!configFile.GetNextParagraph(line, disabledLine, eof) || (line.compare("[GPIO]") != 0)) && !eof) {}
    if (eof)
        return false;

-//    printf("readConfig - Start 2 line: %s, disabbledLine: %d\n", line.c_str(), (int) disabledLine);
+//    ESP_LOGD(TAG, "readConfig - Start 2 line: %s, disabbledLine: %d", line.c_str(), (int) disabledLine);


    _isEnabled = !disabledLine;
@@ -314,52 +326,59 @@ bool GpioHandler::readConfig()
    if (!_isEnabled)
        return false;

-//    printf("readConfig - Start 3\n");
+//    ESP_LOGD(TAG, "readConfig - Start 3");

+#ifdef ENABLE_MQTT
 //    std::string mainTopicMQTT = "";
-    std::string mainTopicMQTT = GetMQTTMainTopic();
+    std::string mainTopicMQTT = mqttServer_getMainTopic();
    if (mainTopicMQTT.length() > 0)
    {
        mainTopicMQTT = mainTopicMQTT + "/GPIO";
-        ESP_LOGD(TAG_SERVERGPIO, "MAINTOPICMQTT found\r\n");
+        ESP_LOGD(TAG, "MAINTOPICMQTT found");
    }
-
+#endif // ENABLE_MQTT
    bool registerISR = false;
    while (configFile.getNextLine(&line, disabledLine, eof) && !configFile.isNewParagraph(line))
    {
-        zerlegt = configFile.ZerlegeZeile(line);
+        splitted = ZerlegeZeile(line);
        // const std::regex pieces_regex("IO([0-9]{1,2})");
        // std::smatch pieces_match;
-        // if (std::regex_match(zerlegt[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
+        // if (std::regex_match(splitted[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
        // {
        //     std::string gpioStr = pieces_match[1];
-        ESP_LOGD(TAG_SERVERGPIO, "conf param %s\r\n", toUpper(zerlegt[0]).c_str());
-        if (toUpper(zerlegt[0]) == "MAINTOPICMQTT") {
-//            ESP_LOGD(TAG_SERVERGPIO, "MAINTOPICMQTT found\r\n");
-//            mainTopicMQTT = zerlegt[1];
-        } else if ((zerlegt[0].rfind("IO", 0) == 0) && (zerlegt.size() >= 6))
+        ESP_LOGD(TAG, "conf param %s", toUpper(splitted[0]).c_str());
+        if (toUpper(splitted[0]) == "MAINTOPICMQTT") {
+//            ESP_LOGD(TAG, "MAINTOPICMQTT found");
+//            mainTopicMQTT = splitted[1];
+        } else if ((splitted[0].rfind("IO", 0) == 0) && (splitted.size() >= 6))
        {
-            ESP_LOGI(TAG_SERVERGPIO,"Enable GP%s in %s mode", zerlegt[0].c_str(), zerlegt[1].c_str());
-            std::string gpioStr = zerlegt[0].substr(2, 2);
+            ESP_LOGI(TAG,"Enable GP%s in %s mode", splitted[0].c_str(), splitted[1].c_str());
+            std::string gpioStr = splitted[0].substr(2, 2);
            gpio_num_t gpioNr = (gpio_num_t)atoi(gpioStr.c_str());
-            gpio_pin_mode_t pinMode = resolvePinMode(toLower(zerlegt[1]));
-            gpio_int_type_t intType = resolveIntType(toLower(zerlegt[2]));
-            uint16_t dutyResolution = (uint8_t)atoi(zerlegt[3].c_str());
-            bool mqttEnabled = toLower(zerlegt[4]) == "true";
-            bool httpEnabled = toLower(zerlegt[5]) == "true";
+            gpio_pin_mode_t pinMode = resolvePinMode(toLower(splitted[1]));
+            gpio_int_type_t intType = resolveIntType(toLower(splitted[2]));
+            uint16_t dutyResolution = (uint8_t)atoi(splitted[3].c_str());
+#ifdef ENABLE_MQTT 
+            bool mqttEnabled = (toLower(splitted[4]) == "true");
+#endif // ENABLE_MQTT
+            bool httpEnabled = (toLower(splitted[5]) == "true");
            char gpioName[100];
-            if (zerlegt.size() >= 7) {
-                strcpy(gpioName, trim(zerlegt[6]).c_str());
+            if (splitted.size() >= 7) {
+                strcpy(gpioName, trim(splitted[6]).c_str());
            } else {
                sprintf(gpioName, "GPIO%d", gpioNr);
            }
+#ifdef ENABLE_MQTT            
            std::string mqttTopic = mqttEnabled ? (mainTopicMQTT + "/" + gpioName) : "";
+#else // ENABLE_MQTT
+            std::string mqttTopic = "";
+#endif // ENABLE_MQTT
            GpioPin* gpioPin = new GpioPin(gpioNr, gpioName, pinMode, intType,dutyResolution, mqttTopic, httpEnabled);
            (*gpioMap)[gpioNr] = gpioPin;

            if (pinMode == GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X)
            {
-                printf("Set WS2812 to GPIO %d\n", gpioNr);
+                ESP_LOGD(TAG, "Set WS2812 to GPIO %d", gpioNr);
                gpioExtLED = gpioNr;
            }

@@ -367,28 +386,28 @@ bool GpioHandler::readConfig()
                registerISR = true;
            }
        }
-        if (toUpper(zerlegt[0]) == "LEDNUMBERS")
+        if (toUpper(splitted[0]) == "LEDNUMBERS")
        {
-            LEDNumbers = stoi(zerlegt[1]);
+            LEDNumbers = stoi(splitted[1]);
        }
-        if (toUpper(zerlegt[0]) == "LEDCOLOR")
+        if (toUpper(splitted[0]) == "LEDCOLOR")
        {
            uint8_t _r, _g, _b;
-            _r = stoi(zerlegt[1]);
-            _g = stoi(zerlegt[2]);
-            _b = stoi(zerlegt[3]);
+            _r = stoi(splitted[1]);
+            _g = stoi(splitted[2]);
+            _b = stoi(splitted[3]);

            LEDColor = Rgb{_r, _g, _b};
        }
-        if (toUpper(zerlegt[0]) == "LEDTYPE")
+        if (toUpper(splitted[0]) == "LEDTYPE")
        {
-            if (zerlegt[1] == "WS2812")
+            if (splitted[1] == "WS2812")
                LEDType = LED_WS2812;
-            if (zerlegt[1] == "WS2812B")
+            if (splitted[1] == "WS2812B")
                LEDType = LED_WS2812B;
-            if (zerlegt[1] == "SK6812")
+            if (splitted[1] == "SK6812")
                LEDType = LED_SK6812;
-            if (zerlegt[1] == "WS2813")
+            if (splitted[1] == "WS2813")
                LEDType = LED_WS2813;
        }
    }
@@ -400,10 +419,10 @@ bool GpioHandler::readConfig()

    if (gpioExtLED > 0)
    {
-    //     LogFile.WriteToFile("Startsequence 06");      // Nremove
+    //     LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Startsequence 06");      // Nremove
 //        vTaskDelay( xDelay );   
 //        xDelay = 5000 / portTICK_PERIOD_MS;
-//        printf("main: sleep for : %ldms\n", (long) xDelay);
+//        ESP_LOGD(TAG, "main: sleep for: %ldms", (long) xDelay);

 //        SmartLed leds( LED_WS2812, 2, GPIO_NUM_12, 0, DoubleBuffer );

@@ -420,7 +439,7 @@ bool GpioHandler::readConfig()

 void GpioHandler::clear() 
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::clear\r\n");
+    ESP_LOGD(TAG, "GpioHandler::clear");

    if (gpioMap != NULL) {
        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
@@ -434,7 +453,7 @@ void GpioHandler::clear()
 
 void GpioHandler::registerGpioUri() 
 {
-    ESP_LOGI(TAG_SERVERGPIO, "server_GPIO - Registering URI handlers");
+    ESP_LOGI(TAG, "server_GPIO - Registering URI handlers");
    
    httpd_uri_t camuri = { };
    camuri.method    = HTTP_GET;
@@ -446,7 +465,7 @@ void GpioHandler::registerGpioUri()

 esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
 {
-    ESP_LOGD(TAG_SERVERGPIO, "handleHttpRequest");
+    ESP_LOGD(TAG, "handleHttpRequest");

    if (gpioMap == NULL) {
        std::string resp_str = "GPIO handler not initialized";
@@ -458,18 +477,18 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
    LogFile.WriteHeapInfo("handler_switch_GPIO - Start");    
 #endif

-    LogFile.WriteToFile("handler_switch_GPIO");    
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_switch_GPIO");
    char _query[200];
    char _valueGPIO[30];    
    char _valueStatus[30];    
    std::string gpio, status;

    if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK) {
-        ESP_LOGD(TAG_SERVERGPIO, "Query: %s", _query);
+        ESP_LOGD(TAG, "Query: %s", _query);
        
        if (httpd_query_key_value(_query, "GPIO", _valueGPIO, 30) == ESP_OK)
        {
-            ESP_LOGD(TAG_SERVERGPIO, "GPIO is found %s", _valueGPIO); 
+            ESP_LOGD(TAG, "GPIO is found %s", _valueGPIO); 
            gpio = std::string(_valueGPIO);
        } else {
            std::string resp_str = "GPIO No is not defined";
@@ -478,7 +497,7 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
        }
        if (httpd_query_key_value(_query, "Status", _valueStatus, 30) == ESP_OK)
        {
-            ESP_LOGD(TAG_SERVERGPIO, "Status is found %s", _valueStatus); 
+            ESP_LOGD(TAG, "Status is found %s", _valueStatus); 
            status = std::string(_valueStatus);
        }
    } else {
@@ -502,7 +521,7 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
    gpio_num_t gpio_num = resolvePinNr(gpionum);
    if (gpio_num == GPIO_NUM_NC)
    {
-        std::string zw = "GPIO" + std::to_string(gpionum) + " not support - only 12 & 13 free";
+        std::string zw = "GPIO" + std::to_string(gpionum) + " unsupported - only 12 & 13 free";
            httpd_resp_sendstr_chunk(req, zw.c_str());
            httpd_resp_sendstr_chunk(req, NULL);          
            return ESP_OK;
@@ -541,7 +560,7 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)

 void GpioHandler::flashLightEnable(bool value) 
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::flashLightEnable %s\r\n", value ? "true" : "false");
+    ESP_LOGD(TAG, "GpioHandler::flashLightEnable %s", value ? "true" : "false");

    if (gpioMap != NULL) {
        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) 
@@ -552,9 +571,9 @@ void GpioHandler::flashLightEnable(bool value)
                it->second->setValue(value, GPIO_SET_SOURCE_INTERNAL, &resp_str);

                if (resp_str == "") {
-                    ESP_LOGD(TAG_SERVERGPIO, "Flash light pin GPIO %d switched to %s\r\n", (int)it->first, (value ? "on" : "off"));
+                    ESP_LOGD(TAG, "Flash light pin GPIO %d switched to %s", (int)it->first, (value ? "on" : "off"));
                } else {
-                    ESP_LOGE(TAG_SERVERGPIO, "Can't set flash light pin GPIO %d.  Error: %s\r\n", (int)it->first, resp_str.c_str());
+                    ESP_LOGE(TAG, "Can't set flash light pin GPIO %d.  Error: %s", (int)it->first, resp_str.c_str());
                }
            } else 
                {
@@ -562,7 +581,7 @@ void GpioHandler::flashLightEnable(bool value)
                    {
 #ifdef __LEDGLOBAL
                        if (leds_global == NULL) {
-                            ESP_LOGI(TAG_SERVERGPIO, "init SmartLed: LEDNumber=%d, GPIO=%d", LEDNumbers, (int)it->second->getGPIO());
+                            ESP_LOGI(TAG, "init SmartLed: LEDNumber=%d, GPIO=%d", LEDNumbers, (int)it->second->getGPIO());
                            leds_global = new SmartLed( LEDType, LEDNumbers, it->second->getGPIO(), 0, DoubleBuffer );
                        } else {
                            // wait until we can update: https://github.com/RoboticsBrno/SmartLeds/issues/10#issuecomment-386921623
@@ -673,6 +692,7 @@ void gpio_handler_deinit() {
 void gpio_handler_destroy()
 {
    if (gpioHandler != NULL) {
+        gpio_handler_deinit();
        delete gpioHandler;
        gpioHandler = NULL;
    }
@@ -682,3 +702,4 @@ GpioHandler* gpio_handler_get()
 {
    return gpioHandler;
 }
+
--- a/code/components/jomjol_controlGPIO/server_GPIO.h
+++ b/code/components/jomjol_controlGPIO/server_GPIO.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef SERVER_GPIO_H
 #define SERVER_GPIO_H

@@ -9,11 +11,6 @@

 #include "SmartLeds.h"

-//#include "ClassControllCamera.h"
-
-// wenn __LEDGLOBAL definiert ist, wird eine globale Variable für die LED-Ansteuerung verwendet, ansonsten lokal und jedesmal neu
-#define __LEDGLOBAL
-
 typedef enum {
    GPIO_PIN_MODE_DISABLED              = 0x0,
    GPIO_PIN_MODE_INPUT                 = 0x1,
@@ -45,7 +42,9 @@ public:
    void init();
    bool getValue(std::string* errorText);
    void setValue(bool value, gpio_set_source setSource, std::string* errorText);
+#ifdef ENABLE_MQTT
    bool handleMQTT(std::string, char* data, int data_len);
+#endif //ENABLE_MQTT
    void publishState();
    void gpioInterrupt(int value);
    gpio_int_type_t getInterruptType() { return _interruptType; }
@@ -77,7 +76,9 @@ public:
    void gpioInterrupt(GpioResult* gpioResult);  
    void flashLightEnable(bool value);
    bool isEnabled() { return _isEnabled; }
+#ifdef ENABLE_MQTT
    void handleMQTTconnect();
+#endif //ENABLE_MQTT

 private:
    std::string _configFile;
@@ -109,4 +110,5 @@ GpioHandler* gpio_handler_get();



-#endif //SERVER_GPIO_H
+#endif //SERVER_GPIO_H
+
--- a/code/components/jomjol_controlcamera/CMakeLists.txt
+++ b/code/components/jomjol_controlcamera/CMakeLists.txt
@@ -4,6 +4,6 @@ list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/proto

 idf_component_register(SRCS ${app_sources}
                    INCLUDE_DIRS "."
-                    REQUIRES esp32-camera-master esp_http_server jomjol_logfile jomjol_image_proc nvs_flash jomjol_fileserver_ota jomjol_controlGPIO)
+                    REQUIRES esp_timer esp32-camera esp_http_server jomjol_logfile jomjol_image_proc nvs_flash jomjol_fileserver_ota jomjol_controlGPIO)


--- a/code/components/jomjol_controlcamera/ClassControllCamera.cpp
+++ b/code/components/jomjol_controlcamera/ClassControllCamera.cpp
--- a/code/components/jomjol_controlcamera/ClassControllCamera.h
+++ b/code/components/jomjol_controlcamera/ClassControllCamera.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef CLASSCONTROLLCAMERA_H
 #define CLASSCONTROLLCAMERA_H

@@ -11,42 +13,101 @@
 #include <string>
 #include <esp_http_server.h>
 #include "CImageBasis.h"
+#include "../../include/defines.h"

+typedef struct
+{
+    uint16_t CamSensor_id;

-#define CAMERA_MODEL_AI_THINKER
+    framesize_t ImageFrameSize = FRAMESIZE_VGA; // 0 - 10
+    gainceiling_t ImageGainceiling;             // Image gain (GAINCEILING_x2, x4, x8, x16, x32, x64 or x128)

+    int ImageQuality;    // 0 - 63
+    int ImageBrightness; // (-2 to 2) - set brightness
+    int ImageContrast;   //-2 - 2
+    int ImageSaturation; //-2 - 2
+    int ImageSharpness;  //-2 - 2
+    bool ImageAutoSharpness;
+    int ImageSpecialEffect; // 0 - 6
+    int ImageWbMode;        // 0 to 4 - if awb_gain enabled (0 - Auto, 1 - Sunny, 2 - Cloudy, 3 - Office, 4 - Home)
+    int ImageAwb;           // white balance enable (0 or 1)
+    int ImageAwbGain;       // Auto White Balance enable (0 or 1)
+    int ImageAec;           // auto exposure off (1 or 0)
+    int ImageAec2;          // automatic exposure sensor  (0 or 1)
+    int ImageAeLevel;       // auto exposure levels (-2 to 2)
+    int ImageAecValue;      // set exposure manually  (0-1200)
+    int ImageAgc;           // auto gain off (1 or 0)
+    int ImageAgcGain;       // set gain manually (0 - 30)
+    int ImageBpc;           // black pixel correction
+    int ImageWpc;           // white pixel correction
+    int ImageRawGma;        // (1 or 0)
+    int ImageLenc;          // lens correction (1 or 0)
+    int ImageHmirror;       // (0 or 1) flip horizontally
+    int ImageVflip;         // Invert image (0 or 1)
+    int ImageDcw;           // downsize enable (1 or 0)

-class CCamera {
-    protected:
-        int ActualQuality;
-        framesize_t ActualResolution;
-        int brightness, contrast, saturation;
-        bool isFixedExposure;
-        int waitbeforepicture_org;
+    int ImageDenoiseLevel; // The OV2640 does not support it, OV3660 and OV5640 (0 to 8)

-    public:
-        int image_height, image_width;
-        
-        CCamera();
-        esp_err_t InitCam();
+    int ImageWidth;
+    int ImageHeight;

-        void LightOnOff(bool status);
-        void LEDOnOff(bool status);
-        esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
-        void SetQualitySize(int qual, framesize_t resol);
-        bool SetBrightnessContrastSaturation(int _brightness, int _contrast, int _saturation);
-        void GetCameraParameter(httpd_req_t *req, int &qual, framesize_t &resol);
+    int ImageLedIntensity;

-        void EnableAutoExposure(int flashdauer);
-        
+    bool ImageZoomEnabled;
+    int ImageZoomOffsetX;
+    int ImageZoomOffsetY;
+    int ImageZoomSize;

-        framesize_t TextToFramesize(const char * text);
+    int WaitBeforePicture;
+    bool isImageSize;

-        esp_err_t CaptureToFile(std::string nm, int delay = 0);
-        esp_err_t CaptureToBasisImage(CImageBasis *_Image, int delay = 0);
+    bool CameraInitSuccessful;
+    bool changedCameraSettings;
+    bool DemoMode;
+    bool SaveAllFiles;
+} camera_controll_config_temp_t;
+
+extern camera_controll_config_temp_t CCstatus;
+
+class CCamera
+{
+protected:
+    void ledc_init(void);
+    bool loadNextDemoImage(camera_fb_t *fb);
+    long GetFileSize(std::string filename);
+    void SetCamWindow(sensor_t *s, int frameSizeX, int frameSizeY, int xOffset, int yOffset, int xTotal, int yTotal, int xOutput, int yOutput, int imageVflip);
+    void SetImageWidthHeightFromResolution(framesize_t resol);
+    void SanitizeZoomParams(int imageSize, int frameSizeX, int frameSizeY, int &imageWidth, int &imageHeight, int &zoomOffsetX, int &zoomOffsetY);
+
+public:
+    CCamera(void);
+    esp_err_t InitCam(void);
+
+    void LightOnOff(bool status);
+    void LEDOnOff(bool status);
+
+    esp_err_t setSensorDatenFromCCstatus(void);
+    esp_err_t getSensorDatenToCCstatus(void);
+
+    int ov5640_set_gainceiling(sensor_t *s, gainceiling_t level);
+
+    esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
+    esp_err_t CaptureToStream(httpd_req_t *req, bool FlashlightOn);
+
+    void SetQualityZoomSize(int qual, framesize_t resol, bool zoomEnabled, int zoomOffsetX, int zoomOffsetY, int imageSize, int imageVflip);
+    void SetZoomSize(bool zoomEnabled, int zoomOffsetX, int zoomOffsetY, int imageSize, int imageVflip);
+    void SetCamSharpness(bool _autoSharpnessEnabled, int _sharpnessLevel);
+
+    void SetLEDIntensity(float _intrel);
+    bool testCamera(void);
+    bool getCameraInitSuccessful(void);
+    void useDemoMode(void);
+
+    framesize_t TextToFramesize(const char *text);
+
+    esp_err_t CaptureToFile(std::string nm, int delay = 0);
+    esp_err_t CaptureToBasisImage(CImageBasis *_Image, int delay = 0);
 };

-
 extern CCamera Camera;
-
 #endif
--- a/code/components/jomjol_controlcamera/img_converters.h
+++ b/code/components/jomjol_controlcamera/img_converters.h
@@ -1,126 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _IMG_CONVERTERS_H_
-#define _IMG_CONVERTERS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_camera.h"
-
-typedef size_t (* jpg_out_cb)(void * arg, size_t index, const void* data, size_t len);
-
-/**
- * @brief Convert image buffer to JPEG
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool fmt2jpg_cb(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert camera frame buffer to JPEG
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool frame2jpg_cb(camera_fb_t * fb, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert image buffer to JPEG buffer
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2jpg(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to JPEG buffer
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2jpg(camera_fb_t * fb, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to BMP buffer
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2bmp(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to BMP buffer
- *
- * @param fb        Source camera frame buffer
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2bmp(camera_fb_t * fb, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to RGB888 buffer (used for face detection)
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param format    Format of the source image
- * @param rgb_buf   Pointer to the output buffer (width * height * 3)
- *
- * @return true on success
- */
-bool fmt2rgb888(const uint8_t *src_buf, size_t src_len, pixformat_t format, uint8_t * rgb_buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _IMG_CONVERTERS_H_ */
--- a/code/components/jomjol_controlcamera/ov2640_sharpness.cpp
+++ b/code/components/jomjol_controlcamera/ov2640_sharpness.cpp
@@ -0,0 +1,152 @@
+#include <stdint.h>
+#include "esp_camera.h"
+#include "ov2640_sharpness.h"
+
+
+const static uint8_t OV2640_SHARPNESS_AUTO[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0x20, 0x20,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t OV2640_SHARPNESS_MANUAL[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0x00, 0x20,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t OV2640_SHARPNESS_LEVEL0[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC0, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL1[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC1, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL2[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC2, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL3[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC4, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL4[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC8, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL5[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xD0, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL6[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xDF, 0x1F,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t *OV2640_SETTING_SHARPNESS[]=
+{
+    OV2640_SHARPNESS_LEVEL0, // -3 sharpness
+    OV2640_SHARPNESS_LEVEL1,
+    OV2640_SHARPNESS_LEVEL2,
+    OV2640_SHARPNESS_LEVEL3,
+    OV2640_SHARPNESS_LEVEL4,
+    OV2640_SHARPNESS_LEVEL5,
+    OV2640_SHARPNESS_LEVEL6  // +3 sharpness
+};
+
+#define OV2640_MAXLEVEL_SHARPNESS 6
+
+
+static int table_mask_write(sensor_t *sensor, const uint8_t* ptab)
+{
+    uint8_t address;
+    uint8_t value;
+    uint8_t orgval;
+    uint8_t mask;
+    const uint8_t *pdata = ptab;
+
+    if (pdata == NULL)
+	{
+        return -1;
+	}
+
+    while (1)
+    {   
+        address = *pdata++;
+        value = *pdata++;
+        mask = *pdata++;
+		
+        if ((address == 0) && (value == 0) && (mask == 0))
+		{
+            break;
+		}
+		
+        sensor->set_reg(sensor, address, mask, value);
+    }   
+
+    return 0;
+}
+
+
+int ov2640_enable_auto_sharpness(sensor_t *sensor)
+{
+    table_mask_write(sensor, OV2640_SHARPNESS_AUTO);
+	
+    return 0;
+}
+
+
+int ov2640_set_sharpness(sensor_t *sensor, int sharpness)
+{
+	int sharpness_temp = 0;
+	
+    if (sharpness < -3)
+	{
+        sharpness_temp = -3;
+	}
+	
+    if (sharpness > OV2640_MAXLEVEL_SHARPNESS - 3)
+	{
+        sharpness_temp = OV2640_MAXLEVEL_SHARPNESS - 3;
+	}	
+
+    table_mask_write(sensor, OV2640_SHARPNESS_MANUAL);
+    table_mask_write(sensor, OV2640_SETTING_SHARPNESS[sharpness_temp + 3]);
+	
+    return 0;
+}
--- a/code/components/jomjol_controlcamera/ov2640_sharpness.h
+++ b/code/components/jomjol_controlcamera/ov2640_sharpness.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef OV2640_SHARPNESS_H
+#define OV2640_SHARPNESS_H
+
+#include "esp_camera.h"
+
+int ov2640_enable_auto_sharpness(sensor_t *sensor);
+int ov2640_set_sharpness(sensor_t *sensor, int sharpness); // -3 to +3, -4 for auto-sharpness
+
+#endif
--- a/code/components/jomjol_controlcamera/sensor.h
+++ b/code/components/jomjol_controlcamera/sensor.h
@@ -1,245 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * Sensor abstraction layer.
- *
- */
-#ifndef __SENSOR_H__
-#define __SENSOR_H__
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    OV9650_PID = 0x96,
-    OV7725_PID = 0x77,
-    OV2640_PID = 0x26,
-    OV3660_PID = 0x3660,
-    OV5640_PID = 0x5640,
-    OV7670_PID = 0x76,
-    NT99141_PID = 0x1410,
-    GC2145_PID = 0x2145,
-    GC032A_PID = 0x232a,
-    GC0308_PID = 0x9b,
-} camera_pid_t;
-
-typedef enum {
-    CAMERA_OV7725,
-    CAMERA_OV2640,
-    CAMERA_OV3660,
-    CAMERA_OV5640,
-    CAMERA_OV7670,
-    CAMERA_NT99141,
-    CAMERA_GC2145,
-    CAMERA_GC032A,
-    CAMERA_GC0308,
-    CAMERA_MODEL_MAX,
-    CAMERA_NONE,
-} camera_model_t;
-
-typedef enum {
-    OV2640_SCCB_ADDR   = 0x30,// 0x60 >> 1
-    OV5640_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    OV3660_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    OV7725_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    OV7670_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    NT99141_SCCB_ADDR  = 0x2A,// 0x54 >> 1
-    GC2145_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    GC032A_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    GC0308_SCCB_ADDR   = 0x21,// 0x42 >> 1
-} camera_sccb_addr_t;
-
-typedef enum {
-    PIXFORMAT_RGB565,    // 2BPP/RGB565
-    PIXFORMAT_YUV422,    // 2BPP/YUV422
-    PIXFORMAT_GRAYSCALE, // 1BPP/GRAYSCALE
-    PIXFORMAT_JPEG,      // JPEG/COMPRESSED
-    PIXFORMAT_RGB888,    // 3BPP/RGB888
-    PIXFORMAT_RAW,       // RAW
-    PIXFORMAT_RGB444,    // 3BP2P/RGB444
-    PIXFORMAT_RGB555,    // 3BP2P/RGB555
-} pixformat_t;
-
-typedef enum {
-    FRAMESIZE_96X96,    // 96x96
-    FRAMESIZE_QQVGA,    // 160x120
-    FRAMESIZE_QCIF,     // 176x144
-    FRAMESIZE_HQVGA,    // 240x176
-    FRAMESIZE_240X240,  // 240x240
-    FRAMESIZE_QVGA,     // 320x240
-    FRAMESIZE_CIF,      // 400x296
-    FRAMESIZE_HVGA,     // 480x320
-    FRAMESIZE_VGA,      // 640x480
-    FRAMESIZE_SVGA,     // 800x600
-    FRAMESIZE_XGA,      // 1024x768
-    FRAMESIZE_HD,       // 1280x720
-    FRAMESIZE_SXGA,     // 1280x1024
-    FRAMESIZE_UXGA,     // 1600x1200
-    // 3MP Sensors
-    FRAMESIZE_FHD,      // 1920x1080
-    FRAMESIZE_P_HD,     //  720x1280
-    FRAMESIZE_P_3MP,    //  864x1536
-    FRAMESIZE_QXGA,     // 2048x1536
-    // 5MP Sensors
-    FRAMESIZE_QHD,      // 2560x1440
-    FRAMESIZE_WQXGA,    // 2560x1600
-    FRAMESIZE_P_FHD,    // 1080x1920
-    FRAMESIZE_QSXGA,    // 2560x1920
-    FRAMESIZE_INVALID
-} framesize_t;
-
-typedef struct {
-    const camera_model_t model;
-    const char *name;
-    const camera_sccb_addr_t sccb_addr;
-    const camera_pid_t pid;
-    const framesize_t max_size;
-    const bool support_jpeg;
-} camera_sensor_info_t;
-
-typedef enum {
-    ASPECT_RATIO_4X3,
-    ASPECT_RATIO_3X2,
-    ASPECT_RATIO_16X10,
-    ASPECT_RATIO_5X3,
-    ASPECT_RATIO_16X9,
-    ASPECT_RATIO_21X9,
-    ASPECT_RATIO_5X4,
-    ASPECT_RATIO_1X1,
-    ASPECT_RATIO_9X16
-} aspect_ratio_t;
-
-typedef enum {
-    GAINCEILING_2X,
-    GAINCEILING_4X,
-    GAINCEILING_8X,
-    GAINCEILING_16X,
-    GAINCEILING_32X,
-    GAINCEILING_64X,
-    GAINCEILING_128X,
-} gainceiling_t;
-
-typedef struct {
-        uint16_t max_width;
-        uint16_t max_height;
-        uint16_t start_x;
-        uint16_t start_y;
-        uint16_t end_x;
-        uint16_t end_y;
-        uint16_t offset_x;
-        uint16_t offset_y;
-        uint16_t total_x;
-        uint16_t total_y;
-} ratio_settings_t;
-
-typedef struct {
-        const uint16_t width;
-        const uint16_t height;
-        const aspect_ratio_t aspect_ratio;
-} resolution_info_t;
-
-// Resolution table (in sensor.c)
-extern const resolution_info_t resolution[];
-// camera sensor table (in sensor.c)
-extern const camera_sensor_info_t camera_sensor[];
-
-typedef struct {
-    uint8_t MIDH;
-    uint8_t MIDL;
-    uint16_t PID;
-    uint8_t VER;
-} sensor_id_t;
-
-typedef struct {
-    framesize_t framesize;//0 - 10
-    bool scale;
-    bool binning;
-    uint8_t quality;//0 - 63
-    int8_t brightness;//-2 - 2
-    int8_t contrast;//-2 - 2
-    int8_t saturation;//-2 - 2
-    int8_t sharpness;//-2 - 2
-    uint8_t denoise;
-    uint8_t special_effect;//0 - 6
-    uint8_t wb_mode;//0 - 4
-    uint8_t awb;
-    uint8_t awb_gain;
-    uint8_t aec;
-    uint8_t aec2;
-    int8_t ae_level;//-2 - 2
-    uint16_t aec_value;//0 - 1200
-    uint8_t agc;
-    uint8_t agc_gain;//0 - 30
-    uint8_t gainceiling;//0 - 6
-    uint8_t bpc;
-    uint8_t wpc;
-    uint8_t raw_gma;
-    uint8_t lenc;
-    uint8_t hmirror;
-    uint8_t vflip;
-    uint8_t dcw;
-    uint8_t colorbar;
-} camera_status_t;
-
-typedef struct _sensor sensor_t;
-typedef struct _sensor {
-    sensor_id_t id;             // Sensor ID.
-    uint8_t  slv_addr;          // Sensor I2C slave address.
-    pixformat_t pixformat;
-    camera_status_t status;
-    int xclk_freq_hz;
-
-    // Sensor function pointers
-    int  (*init_status)         (sensor_t *sensor);
-    int  (*reset)               (sensor_t *sensor);
-    int  (*set_pixformat)       (sensor_t *sensor, pixformat_t pixformat);
-    int  (*set_framesize)       (sensor_t *sensor, framesize_t framesize);
-    int  (*set_contrast)        (sensor_t *sensor, int level);
-    int  (*set_brightness)      (sensor_t *sensor, int level);
-    int  (*set_saturation)      (sensor_t *sensor, int level);
-    int  (*set_sharpness)       (sensor_t *sensor, int level);
-    int  (*set_denoise)         (sensor_t *sensor, int level);
-    int  (*set_gainceiling)     (sensor_t *sensor, gainceiling_t gainceiling);
-    int  (*set_quality)         (sensor_t *sensor, int quality);
-    int  (*set_colorbar)        (sensor_t *sensor, int enable);
-    int  (*set_whitebal)        (sensor_t *sensor, int enable);
-    int  (*set_gain_ctrl)       (sensor_t *sensor, int enable);
-    int  (*set_exposure_ctrl)   (sensor_t *sensor, int enable);
-    int  (*set_hmirror)         (sensor_t *sensor, int enable);
-    int  (*set_vflip)           (sensor_t *sensor, int enable);
-
-    int  (*set_aec2)            (sensor_t *sensor, int enable);
-    int  (*set_awb_gain)        (sensor_t *sensor, int enable);
-    int  (*set_agc_gain)        (sensor_t *sensor, int gain);
-    int  (*set_aec_value)       (sensor_t *sensor, int gain);
-
-    int  (*set_special_effect)  (sensor_t *sensor, int effect);
-    int  (*set_wb_mode)         (sensor_t *sensor, int mode);
-    int  (*set_ae_level)        (sensor_t *sensor, int level);
-
-    int  (*set_dcw)             (sensor_t *sensor, int enable);
-    int  (*set_bpc)             (sensor_t *sensor, int enable);
-    int  (*set_wpc)             (sensor_t *sensor, int enable);
-
-    int  (*set_raw_gma)         (sensor_t *sensor, int enable);
-    int  (*set_lenc)            (sensor_t *sensor, int enable);
-
-    int  (*get_reg)             (sensor_t *sensor, int reg, int mask);
-    int  (*set_reg)             (sensor_t *sensor, int reg, int mask, int value);
-    int  (*set_res_raw)         (sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning);
-    int  (*set_pll)             (sensor_t *sensor, int bypass, int mul, int sys, int root, int pre, int seld5, int pclken, int pclk);
-    int  (*set_xclk)            (sensor_t *sensor, int timer, int xclk);
-} sensor_t;
-
-camera_sensor_info_t *esp_camera_sensor_get_info(sensor_id_t *id);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SENSOR_H__ */
--- a/code/components/jomjol_controlcamera/server_camera.cpp
+++ b/code/components/jomjol_controlcamera/server_camera.cpp
@@ -5,245 +5,299 @@

 #include "esp_camera.h"
 #include "ClassControllCamera.h"
+#include "MainFlowControl.h"

 #include "ClassLogFile.h"
+#include "esp_log.h"

-// #define SCRATCH_BUFSIZE2  8192 
-// char scratch2[SCRATCH_BUFSIZE2];
+#include "../../include/defines.h"

-//#define DEBUG_DETAIL_ON   
-static const char *TAGPARTCAMERA = "server_camera";
+static const char *TAG = "server_cam";

+void PowerResetCamera()
+{
+#if CAM_PIN_PWDN == GPIO_NUM_NC // Use reset only if pin is available
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No power down pin availbale to reset camera");
+#else
+    ESP_LOGD(TAG, "Resetting camera by power down line");
+    gpio_config_t conf;
+    conf.intr_type = GPIO_INTR_DISABLE;
+    conf.pin_bit_mask = 1LL << CAM_PIN_PWDN;
+    conf.mode = GPIO_MODE_OUTPUT;
+    conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+    conf.pull_up_en = GPIO_PULLUP_DISABLE;
+    gpio_config(&conf);

-void PowerResetCamera(){
-        ESP_LOGD(TAGPARTCAMERA, "Resetting camera by power down line");
-        gpio_config_t conf;
-        conf.intr_type = GPIO_INTR_DISABLE;
-        conf.pin_bit_mask = 1LL << GPIO_NUM_32;
-        conf.mode = GPIO_MODE_OUTPUT;
-        conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-        conf.pull_up_en = GPIO_PULLUP_DISABLE;
-        gpio_config(&conf);
-
-        // carefull, logic is inverted compared to reset pin
-        gpio_set_level(GPIO_NUM_32, 1);
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-        gpio_set_level(GPIO_NUM_32, 0);
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    // carefull, logic is inverted compared to reset pin
+    gpio_set_level(CAM_PIN_PWDN, 1);
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+    gpio_set_level(CAM_PIN_PWDN, 0);
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+#endif
 }

-
 esp_err_t handler_lightOn(httpd_req_t *req)
 {
-#ifdef DEBUG_DETAIL_ON   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOn - Start");
-    printf("handler_lightOn uri:\n"); printf(req->uri); printf("\n");
+    ESP_LOGD(TAG, "handler_lightOn uri: %s", req->uri);
 #endif

-    Camera.LightOnOff(true);
-    const char* resp_str = (const char*) req->user_ctx;
-    httpd_resp_send(req, resp_str, strlen(resp_str));  
+    if (Camera.getCameraInitSuccessful())
+    {
+        Camera.LightOnOff(true);
+        const char *resp_str = (const char *)req->user_ctx;
+        httpd_resp_send(req, resp_str, strlen(resp_str));
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lighton not available!");
+        return ESP_ERR_NOT_FOUND;
+    }

-#ifdef DEBUG_DETAIL_ON   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOn - Done");
 #endif

    return ESP_OK;
-};
+}

 esp_err_t handler_lightOff(httpd_req_t *req)
 {
-#ifdef DEBUG_DETAIL_ON   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOff - Start");
-    printf("handler_lightOff uri:\n"); printf(req->uri); printf("\n");
+    ESP_LOGD(TAG, "handler_lightOff uri: %s", req->uri);
 #endif
-    Camera.LightOnOff(false);
-    const char* resp_str = (const char*) req->user_ctx;
-    httpd_resp_send(req, resp_str, strlen(resp_str));       

-#ifdef DEBUG_DETAIL_ON   
+    if (Camera.getCameraInitSuccessful())
+    {
+        Camera.LightOnOff(false);
+        const char *resp_str = (const char *)req->user_ctx;
+        httpd_resp_send(req, resp_str, strlen(resp_str));
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lightoff not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOff - Done");
 #endif

    return ESP_OK;
-};
+}

 esp_err_t handler_capture(httpd_req_t *req)
 {
-#ifdef DEBUG_DETAIL_ON   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_capture - Start");
 #endif

-    int quality;
-    framesize_t res;
-
-    Camera.GetCameraParameter(req, quality, res);
-
-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
-#endif
-
-    Camera.SetQualitySize(quality, res);
-
-    esp_err_t ressult;
-    ressult = Camera.CaptureToHTTP(req);
-
-#ifdef DEBUG_DETAIL_ON   
-    LogFile.WriteHeapInfo("handler_capture - Done");
-#endif
-
-    return ressult;
-};
-
-
-esp_err_t handler_capture_with_ligth(httpd_req_t *req)
-{
-#ifdef DEBUG_DETAIL_ON  
-    LogFile.WriteHeapInfo("handler_capture_with_ligth - Start");
-#endif
-    char _query[100];
-    char _delay[10];
-
-    int quality;
-    framesize_t res;    
-    int delay = 2500;
-
-    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    if (Camera.getCameraInitSuccessful())
    {
-        printf("Query: "); printf(_query); printf("\n");
-        if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
        {
-#ifdef DEBUG_DETAIL_ON   
-            printf("Delay: "); printf(_delay); printf("\n");    
-#endif        
-            delay = atoi(_delay);
-
-            if (delay < 0)
-                delay = 0;
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
        }
-    };

-    Camera.GetCameraParameter(req, quality, res);
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        

-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
+        esp_err_t result;
+        result = Camera.CaptureToHTTP(req);
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture - Done");
 #endif

-    Camera.SetQualitySize(quality, res);
-    Camera.LightOnOff(true);
-    const TickType_t xDelay = delay / portTICK_PERIOD_MS;
-    vTaskDelay( xDelay );
+        return result;
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}

-    esp_err_t ressult;
-    ressult = Camera.CaptureToHTTP(req);  
-
-    Camera.LightOnOff(false);
-
-#ifdef DEBUG_DETAIL_ON   
-    LogFile.WriteHeapInfo("handler_capture_with_ligth - Done");
+esp_err_t handler_capture_with_light(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_capture_with_light - Start");
 #endif

-    return ressult;
-};
+    if (Camera.getCameraInitSuccessful())
+    {
+        char _query[100];
+        char _delay[10];
+        int delay = 2500;

+        if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+        {
+            ESP_LOGD(TAG, "Query: %s", _query);

+            if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+            {
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Delay: %s", _delay);
+#endif
+                delay = atoi(_delay);
+
+                if (delay < 0)
+                {
+                    delay = 0;
+                }
+            }
+        }
+
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
+        {
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
+        }
+
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        
+
+        Camera.LightOnOff(true);
+        const TickType_t xDelay = delay / portTICK_PERIOD_MS;
+        vTaskDelay(xDelay);
+
+        esp_err_t result;
+        result = Camera.CaptureToHTTP(req);
+
+        Camera.LightOnOff(false);
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture_with_light - Done");
+#endif
+
+        return result;
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture_with_flashlight not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}

 esp_err_t handler_capture_save_to_file(httpd_req_t *req)
 {
-#ifdef DEBUG_DETAIL_ON   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_capture_save_to_file - Start");
 #endif

-    char _query[100];
-    char _delay[10];
-    int delay = 0;
-    char filename[100];
-    std::string fn = "/sdcard/";
-
-
-    int quality;
-    framesize_t res;    
-
-    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    if (Camera.getCameraInitSuccessful())
    {
-        printf("Query: "); printf(_query); printf("\n");
-        if (httpd_query_key_value(_query, "filename", filename, 100) == ESP_OK)
+        char _query[100];
+        char _delay[10];
+        int delay = 0;
+        char filename[100];
+        std::string fn = "/sdcard/";
+
+        if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
        {
-            fn.append(filename);
-#ifdef DEBUG_DETAIL_ON   
-            printf("Filename: "); printf(fn.c_str()); printf("\n");            
+            ESP_LOGD(TAG, "Query: %s", _query);
+
+            if (httpd_query_key_value(_query, "filename", filename, 100) == ESP_OK)
+            {
+                fn.append(filename);
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Filename: %s", fn.c_str());
 #endif
+            }
+            else
+            {
+                fn.append("noname.jpg");
+            }
+
+            if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+            {
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Delay: %s", _delay);
+#endif
+                delay = atoi(_delay);
+
+                if (delay < 0)
+                {
+                    delay = 0;
+                }
+            }
        }
        else
-            fn.append("noname.jpg");
-
-        if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
        {
-#ifdef DEBUG_DETAIL_ON   
-            printf("Delay: "); printf(_delay); printf("\n");            
-#endif
-            delay = atoi(_delay);
-
-            if (delay < 0)
-                delay = 0;
+            fn.append("noname.jpg");
        }

+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
+        {
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
+        }
+
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        
+
+        esp_err_t result;
+        result = Camera.CaptureToFile(fn, delay);
+
+        const char *resp_str = (const char *)fn.c_str();
+        httpd_resp_send(req, resp_str, strlen(resp_str));
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture_save_to_file - Done");
+#endif
+
+        return result;
    }
    else
-        fn.append("noname.jpg");
-
-    Camera.GetCameraParameter(req, quality, res);
-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
-#endif
-    Camera.SetQualitySize(quality, res);
-
-    esp_err_t ressult;
-    ressult = Camera.CaptureToFile(fn, delay);  
-
-    const char* resp_str = (const char*) fn.c_str();
-    httpd_resp_send(req, resp_str, strlen(resp_str));  
-  
-#ifdef DEBUG_DETAIL_ON   
-    LogFile.WriteHeapInfo("handler_capture_save_to_file - Done");
-#endif
-
-    return ressult;
-};
-
-
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /save not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}

 void register_server_camera_uri(httpd_handle_t server)
 {
-#ifdef DEBUG_DETAIL_ON   
-    ESP_LOGI(TAGPARTCAMERA, "server_part_camera - Registering URI handlers");
+#ifdef DEBUG_DETAIL_ON
+    ESP_LOGI(TAG, "server_part_camera - Registering URI handlers");
 #endif

-    httpd_uri_t camuri = { };
-    camuri.method    = HTTP_GET;
+    httpd_uri_t camuri = {};
+    camuri.method = HTTP_GET;

-    camuri.uri       = "/lighton";
-    camuri.handler   = handler_lightOn;
-    camuri.user_ctx  = (void*) "Light On";    
+    camuri.uri = "/lighton";
+    camuri.handler = handler_lightOn;
+    camuri.user_ctx = (void *)"Light On";
    httpd_register_uri_handler(server, &camuri);

-    camuri.uri       = "/lightoff";
-    camuri.handler   = handler_lightOff;
-    camuri.user_ctx  = (void*) "Light Off"; 
-    httpd_register_uri_handler(server, &camuri);    
+    camuri.uri = "/lightoff";
+    camuri.handler = handler_lightOff;
+    camuri.user_ctx = (void *)"Light Off";
+    httpd_register_uri_handler(server, &camuri);

-    camuri.uri       = "/capture";
-    camuri.handler   = handler_capture;
-    camuri.user_ctx  = NULL; 
-    httpd_register_uri_handler(server, &camuri);      
+    camuri.uri = "/capture";
+    camuri.handler = handler_capture;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);

-    camuri.uri       = "/capture_with_flashlight";
-    camuri.handler   = handler_capture_with_ligth;
-    camuri.user_ctx  = NULL; 
-    httpd_register_uri_handler(server, &camuri);  
+    camuri.uri = "/capture_with_flashlight";
+    camuri.handler = handler_capture_with_light;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);

-    camuri.uri       = "/save";
-    camuri.handler   = handler_capture_save_to_file;
-    camuri.user_ctx  = NULL; 
-    httpd_register_uri_handler(server, &camuri);    
+    camuri.uri = "/save";
+    camuri.handler = handler_capture_save_to_file;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);
 }
--- a/code/components/jomjol_controlcamera/server_camera.h
+++ b/code/components/jomjol_controlcamera/server_camera.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef JOMJOL_CONTROLCAMERA_H
 #define JOMJOL_CONTROLCAMERA_H

@@ -8,7 +10,6 @@
 //#include "ClassControllCamera.h"

 void register_server_camera_uri(httpd_handle_t server);
-
 void PowerResetCamera();

 #endif
--- a/code/components/jomjol_fileserver_ota/CMakeLists.txt
+++ b/code/components/jomjol_fileserver_ota/CMakeLists.txt
@@ -1,7 +1,7 @@
 FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)

 idf_component_register(SRCS ${app_sources}
-                    INCLUDE_DIRS "." "../../include"
-                    REQUIRES tfmicro esp_http_server app_update esp_http_client nvs_flash jomjol_tfliteclass jomjol_flowcontroll spiffs jomjol_helper jomjol_controlGPIO)
+                    INCLUDE_DIRS "." "../../include" "miniz"
+                    REQUIRES vfs esp_http_server app_update esp_http_client nvs_flash jomjol_tfliteclass jomjol_flowcontroll spiffs jomjol_helper jomjol_controlGPIO)


--- a/code/components/jomjol_fileserver_ota/miniz/ChangeLog.md
+++ b/code/components/jomjol_fileserver_ota/miniz/ChangeLog.md
@@ -0,0 +1,235 @@
+## Changelog
+
+### 3.0.1
+
+ - Fix compilation error with MINIZ_USE_UNALIGNED_LOADS_AND_STORES=1
+
+### 3.0.0
+
+ - Reduce memory usage for inflate. This changes `struct tinfl_decompressor_tag` and therefore requires a major version bump (breaks ABI compatibility)
+ - Add padding to structures so it continues to work if features differ. This also changes some structures
+ - Use _ftelli64, _fseeki64 and stat with MinGW32 and OpenWatcom
+ - Fix varios warnings with OpenWatcom compiler
+ - Avoid using unaligned memory access in UBSan builds
+ - Set MINIZ_LITTLE_ENDIAN only if not set
+ - Add MINIZ_NO_DEFLATE_APIS and MINIZ_NO_INFLATE_APIS
+ - Fix use of uninitialized memory in tinfl_decompress_mem_to_callback()
+ - Use wfopen on windows
+ - Use _wstat64 instead _stat64 on windows
+ - Use level_and_flags after MZ_DEFAULT_COMPRESSION has been handled
+ - Improve endianess detection
+ - Don't use unaligned stores and loads per default
+ - Fix function declaration if MINIZ_NO_STDIO is used
+ - Fix MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 not being set
+ - Remove total files check (its 32-bit uint)
+ - tinfl_decompress: avoid NULL ptr arithmetic UB
+ - miniz_zip: fix mz_zip_reader_extract_to_heap to read correct sizes
+ - Eliminate 64-bit operations on 32-bit machines
+ - Disable treating warnings as error with MSVC
+ - Disable building shared lib via CMake by default
+ - Fixed alignment problems on MacOS
+ - Fixed get error string for MZ_ZIP_TOTAL_ERRORS
+ - Write correct FLEVEL 2-bit value in zlib header
+ - miniz.pc.in: fix include path not containing the "miniz" suffix
+ - Fix compatibility with FreeBSD
+ - pkg-config tweaks
+ - Fix integer overflow in header corruption check
+ - Fix some warnings
+ - tdefl_compress_normal: Avoid NULL ptr arithmetic UB
+ - replace use of stdint.h types with mz_ variants
+ 
+ 
+### 2.2.0
+
+ - Fix examples with amalgamation
+ - Modified cmake script to support shared library mode and find_package
+ - Fix for misleading doc comment on `mz_zip_reader_init_cfile` function
+ - Add include location tolerance and stop forcing `_GNU_SOURCE`
+ - Fix: mz_zip_reader_locate_file_v2 returns an mz_bool
+ - Fix large file system checks
+ - Add #elif to enable an external mz_crc32() to be linked in
+ - Write with dynamic size (size of file/data to be added not known before adding)
+ - Added uncompress2 for zlib compatibility
+ - Add support for building as a Meson subproject
+ - Added OSSFuzz support; Integrate with CIFuzz
+ - Add pkg-config file
+ - Fixed use-of-uninitialized value msan error when copying dist bytes with no output bytes written.
+ - mz_zip_validate_file(): fix memory leak on errors
+ - Fixed MSAN use-of-uninitialized in tinfl_decompress when invalid dist is decoded. In this instance dist was 31 which s_dist_base translates as 0
+ - Add flag to set (compressed) size in local file header
+ - avoid use of uninitialized value in tdefl_record_literal
+
+### 2.1.0
+
+ - More instances of memcpy instead of cast and use memcpy per default
+ - Remove inline for c90 support
+ - New function to read files via callback functions when adding them
+ - Fix out of bounds read while reading Zip64 extended information
+ - guard memcpy when n == 0 because buffer may be NULL
+ - Implement inflateReset() function
+ - Move comp/decomp alloc/free  prototypes under guarding #ifndef MZ_NO_MALLOC
+ - Fix large file support under Windows
+ - Don't warn if _LARGEFILE64_SOURCE is not defined to 1
+ - Fixes for MSVC warnings
+ - Remove check that path of file added to archive contains ':' or '\'
+ - Add !defined check on MINIZ_USE_ALIGNED_LOADS_AND_STORES
+
+### 2.0.8
+
+ - Remove unimplemented functions (mz_zip_locate_file and mz_zip_locate_file_v2)
+ - Add license, changelog, readme and example files to release zip
+ - Fix heap overflow to user buffer in tinfl_status tinfl_decompress
+ - Fix corrupt archive if uncompressed file smaller than 4 byte and the file is added by mz_zip_writer_add_mem*
+
+### 2.0.7
+
+ - Removed need in C++ compiler in cmake build
+ - Fixed a lot of uninitialized value errors found with Valgrind by memsetting m_dict to 0 in tdefl_init
+ - Fix resource leak in mz_zip_reader_init_file_v2
+ - Fix assert with mz_zip_writer_add_mem* w/MZ_DEFAULT_COMPRESSION
+ - cmake build: install library and headers
+ - Remove _LARGEFILE64_SOURCE requirement from apple defines for large files
+
+### 2.0.6
+
+ - Improve MZ_ZIP_FLAG_WRITE_ZIP64 documentation
+ - Remove check for cur_archive_file_ofs > UINT_MAX because cur_archive_file_ofs is not used after this point
+ - Add cmake debug configuration
+ - Fix PNG height when creating png files
+ - Add "iterative" file extraction method based on mz_zip_reader_extract_to_callback.
+ - Option to use memcpy for unaligned data access
+ - Define processor/arch macros as zero if not set to one
+
+### 2.0.4/2.0.5
+
+ - Fix compilation with the various omission compile definitions
+
+### 2.0.3
+
+- Fix GCC/clang compile warnings
+- Added callback for periodic flushes (for ZIP file streaming)
+- Use UTF-8 for file names in ZIP files per default
+
+### 2.0.2
+
+- Fix source backwards compatibility with 1.x
+- Fix a ZIP bit not being set correctly
+
+### 2.0.1
+
+- Added some tests
+- Added CI
+- Make source code ANSI C compatible
+
+### 2.0.0 beta
+
+- Matthew Sitton merged miniz 1.x to Rich Geldreich's vogl ZIP64 changes. Miniz is now licensed as MIT since the vogl code base is MIT licensed
+- Miniz is now split into several files
+- Miniz does now not seek backwards when creating ZIP files. That is the ZIP files can be streamed
+- Miniz automatically switches to the ZIP64 format when the created ZIP files goes over ZIP file limits
+- Similar to [SQLite](https://www.sqlite.org/amalgamation.html) the Miniz source code is amalgamated into one miniz.c/miniz.h pair in a build step (amalgamate.sh). Please use miniz.c/miniz.h in your projects
+- Miniz 2 is only source back-compatible with miniz 1.x. It breaks binary compatibility because structures changed
+
+### v1.16 BETA Oct 19, 2013
+
+Still testing, this release is downloadable from [here](http://www.tenacioussoftware.com/miniz_v116_beta_r1.7z). Two key inflator-only robustness and streaming related changes. Also merged in tdefl_compressor_alloc(), tdefl_compressor_free() helpers to make script bindings easier for rustyzip. I would greatly appreciate any help with testing or any feedback.
+
+The inflator in raw (non-zlib) mode is now usable on gzip or similar streams that have a bunch of bytes following the raw deflate data (problem discovered by rustyzip author williamw520). This version should never read beyond the last byte of the raw deflate data independent of how many bytes you pass into the input buffer.
+
+The inflator now has a new failure status TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS (-4). Previously, if the inflator was starved of bytes and could not make progress (because the input buffer was empty and the caller did not set the TINFL_FLAG_HAS_MORE_INPUT flag - say on truncated or corrupted compressed data stream) it would append all 0's to the input and try to soldier on. This is scary behavior if the caller didn't know when to stop accepting output (because it didn't know how much uncompressed data was expected, or didn't enforce a sane maximum). v1.16 will instead return TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS immediately if it needs 1 or more bytes to make progress, the input buf is empty, and the caller has indicated that no more input is available. This is a "soft" failure, so you can call the inflator again with more input and it will try to continue, or you can give up and fail. This could be very useful in network streaming scenarios.
+
+- The inflator coroutine func. is subtle and complex so I'm being cautious about this release. I would greatly appreciate any help with testing or any feedback.
+         I feel good about these changes, and they've been through several hours of automated testing, but they will probably not fix anything for the majority of prev. users so I'm
+         going to mark this release as beta for a few weeks and continue testing it at work/home on various things.
+- The inflator in raw (non-zlib) mode is now usable on gzip or similar data streams that have a bunch of bytes following the raw deflate data (problem discovered by rustyzip author williamw520).
+         This version should *never* read beyond the last byte of the raw deflate data independent of how many bytes you pass into the input buffer. This issue was caused by the various Huffman bitbuffer lookahead optimizations, and
+         would not be an issue if the caller knew and enforced the precise size of the raw compressed data *or* if the compressed data was in zlib format (i.e. always followed by the byte aligned zlib adler32).
+         So in other words, you can now call the inflator on deflate streams that are followed by arbitrary amounts of data and it's guaranteed that decompression will stop exactly on the last byte.
+- The inflator now has a new failure status: TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS (-4). Previously, if the inflator was starved of bytes and could not make progress (because the input buffer was empty and the
+         caller did not set the TINFL_FLAG_HAS_MORE_INPUT flag - say on truncated or corrupted compressed data stream) it would append all 0's to the input and try to soldier on.
+         This is scary, because in the worst case, I believe it was possible for the prev. inflator to start outputting large amounts of literal data. If the caller didn't know when to stop accepting output
+         (because it didn't know how much uncompressed data was expected, or didn't enforce a sane maximum) it could continue forever. v1.16 cannot fall into this failure mode, instead it'll return
+         TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS immediately if it needs 1 or more bytes to make progress, the input buf is empty, and the caller has indicated that no more input is available. This is a "soft"
+         failure, so you can call the inflator again with more input and it will try to continue, or you can give up and fail. This could be very useful in network streaming scenarios.
+- Added documentation to all the tinfl return status codes, fixed miniz_tester so it accepts double minus params for Linux, tweaked example1.c, added a simple "follower bytes" test to miniz_tester.cpp.
+### v1.15 r4 STABLE - Oct 13, 2013
+
+Merged over a few very minor bug fixes that I fixed in the zip64 branch. This is downloadable from [here](http://code.google.com/p/miniz/downloads/list) and also in SVN head (as of 10/19/13).
+
+
+### v1.15 - Oct. 13, 2013
+
+Interim bugfix release while I work on the next major release with zip64 and streaming compression/decompression support. Fixed the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY bug (thanks kahmyong.moon@hp.com), which could cause the locate files func to not find files when this flag was specified. Also fixed a bug in mz_zip_reader_extract_to_mem_no_alloc() with user provided read buffers (thanks kymoon). I also merged lots of compiler fixes from various github repo branches and Google Code issue reports. I finally added cmake support (only tested under for Linux so far), compiled and tested with clang v3.3 and gcc 4.6 (under Linux), added defl_write_image_to_png_file_in_memory_ex() (supports Y flipping for OpenGL use, real-time compression), added a new PNG example (example6.c - Mandelbrot), and I added 64-bit file I/O support (stat64(), etc.) for glibc.
+
+- Critical fix for the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY bug (thanks kahmyong.moon@hp.com) which could cause locate files to not find files. This bug
+        would only have occurred in earlier versions if you explicitly used this flag, OR if you used mz_zip_extract_archive_file_to_heap() or mz_zip_add_mem_to_archive_file_in_place()
+        (which used this flag). If you can't switch to v1.15 but want to fix this bug, just remove the uses of this flag from both helper funcs (and of course don't use the flag).
+- Bugfix in mz_zip_reader_extract_to_mem_no_alloc() from kymoon when pUser_read_buf is not NULL and compressed size is > uncompressed size
+- Fixing mz_zip_reader_extract_*() funcs so they don't try to extract compressed data from directory entries, to account for weird zipfiles which contain zero-size compressed data on dir entries.
+         Hopefully this fix won't cause any issues on weird zip archives, because it assumes the low 16-bits of zip external attributes are DOS attributes (which I believe they always are in practice).
+- Fixing mz_zip_reader_is_file_a_directory() so it doesn't check the internal attributes, just the filename and external attributes
+- mz_zip_reader_init_file() - missing MZ_FCLOSE() call if the seek failed
+- Added cmake support for Linux builds which builds all the examples, tested with clang v3.3 and gcc v4.6.
+- Clang fix for tdefl_write_image_to_png_file_in_memory() from toffaletti
+- Merged MZ_FORCEINLINE fix from hdeanclark
+- Fix <time.h> include before config #ifdef, thanks emil.brink
+- Added tdefl_write_image_to_png_file_in_memory_ex(): supports Y flipping (super useful for OpenGL apps), and explicit control over the compression level (so you can
+        set it to 1 for real-time compression).
+- Merged in some compiler fixes from paulharris's github repro.
+- Retested this build under Windows (VS 2010, including static analysis), tcc  0.9.26, gcc v4.6 and clang v3.3.
+- Added example6.c, which dumps an image of the mandelbrot set to a PNG file.
+- Modified example2 to help test the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY flag more.
+- In r3: Bugfix to mz_zip_writer_add_file() found during merge: Fix possible src file fclose() leak if alignment bytes+local header file write faiiled
+- In r4: Minor bugfix to mz_zip_writer_add_from_zip_reader(): Was pushing the wrong central dir header offset, appears harmless in this release, but it became a problem in the zip64 branch
+
+### v1.14 - May 20, 2012
+
+(SVN Only) Minor tweaks to get miniz.c compiling with the Tiny C Compiler, added #ifndef MINIZ_NO_TIME guards around utime.h includes. Adding mz_free() function, so the caller can free heap blocks returned by miniz using whatever heap functions it has been configured to use, MSVC specific fixes to use "safe" variants of several functions (localtime_s, fopen_s, freopen_s).
+
+MinGW32/64 GCC 4.6.1 compiler fixes: added MZ_FORCEINLINE, #include <time.h> (thanks fermtect).
+
+Compiler specific fixes, some from fermtect. I upgraded to TDM GCC 4.6.1 and now static __forceinline is giving it fits, so I'm changing all usage of __forceinline to MZ_FORCEINLINE and forcing gcc to use __attribute__((__always_inline__)) (and MSVC to use __forceinline). Also various fixes from fermtect for MinGW32: added #include , 64-bit ftell/fseek fixes.
+
+### v1.13 - May 19, 2012
+
+From jason@cornsyrup.org and kelwert@mtu.edu - Most importantly, fixed mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bits. Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files. Other stuff:
+
+Eliminated a bunch of warnings when compiling with GCC 32-bit/64. Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly "Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
+
+Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64. Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test. Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives. Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
+
+Fix ftell() usage in a few of the examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself). Fix fail logic handling in mz_zip_add_mem_to_archive_file_in_place() so it always calls mz_zip_writer_finalize_archive() and mz_zip_writer_end(), even if the file add fails.
+
+- From jason@cornsyrup.org and kelwert@mtu.edu - Fix mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bit.
+- Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files.
+- Eliminated a bunch of warnings when compiling with GCC 32-bit/64.
+- Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly
+"Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
+- Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64.
+- Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test.
+- Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives.
+- Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
+- Fix ftell() usage in examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself).
+
+### v1.12 - 4/12/12
+
+More comments, added low-level example5.c, fixed a couple minor level_and_flags issues in the archive API's.
+level_and_flags can now be set to MZ_DEFAULT_COMPRESSION. Thanks to Bruce Dawson <bruced@valvesoftware.com> for the feedback/bug report.
+
+### v1.11 - 5/28/11
+
+Added statement from unlicense.org
+
+### v1.10 - 5/27/11
+
+- Substantial compressor optimizations:
+- Level 1 is now ~4x faster than before. The L1 compressor's throughput now varies between 70-110MB/sec. on a Core i7 (actual throughput varies depending on the type of data, and x64 vs. x86).
+- Improved baseline L2-L9 compression perf. Also, greatly improved compression perf. issues on some file types.
+- Refactored the compression code for better readability and maintainability.
+- Added level 10 compression level (L10 has slightly better ratio than level 9, but could have a potentially large drop in throughput on some files).
+
+### v1.09 - 5/15/11
+
+Initial stable release.
+
+
--- a/code/components/jomjol_fileserver_ota/miniz/LICENSE
+++ b/code/components/jomjol_fileserver_ota/miniz/LICENSE
@@ -0,0 +1,22 @@
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example1.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example1.c
@@ -0,0 +1,105 @@
+// example1.c - Demonstrates miniz.c's compress() and uncompress() functions (same as zlib's).
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+#include <stdio.h>
+#include "miniz.h"
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+// The string to compress.
+static const char *s_pStr = "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson.";
+
+int main(int argc, char *argv[])
+{
+  uint step = 0;
+  int cmp_status;
+  uLong src_len = (uLong)strlen(s_pStr);
+  uLong cmp_len = compressBound(src_len);
+  uLong uncomp_len = src_len;
+  uint8 *pCmp, *pUncomp;
+  uint total_succeeded = 0;
+  (void)argc, (void)argv;
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  do
+  {
+    // Allocate buffers to hold compressed and uncompressed data.
+    pCmp = (mz_uint8 *)malloc((size_t)cmp_len);
+    pUncomp = (mz_uint8 *)malloc((size_t)src_len);
+    if ((!pCmp) || (!pUncomp))
+    {
+      printf("Out of memory!\n");
+      return EXIT_FAILURE;
+    }
+
+    // Compress the string.
+    cmp_status = compress(pCmp, &cmp_len, (const unsigned char *)s_pStr, src_len);
+    if (cmp_status != Z_OK)
+    {
+      printf("compress() failed!\n");
+      free(pCmp);
+      free(pUncomp);
+      return EXIT_FAILURE;
+    }
+
+    printf("Compressed from %u to %u bytes\n", (mz_uint32)src_len, (mz_uint32)cmp_len);
+
+    if (step)
+    {
+      // Purposely corrupt the compressed data if fuzzy testing (this is a very crude fuzzy test).
+      uint n = 1 + (rand() % 3);
+      while (n--)
+      {
+        uint i = rand() % cmp_len;
+        pCmp[i] ^= (rand() & 0xFF);
+      }
+    }
+
+    // Decompress.
+    cmp_status = uncompress(pUncomp, &uncomp_len, pCmp, cmp_len);
+    total_succeeded += (cmp_status == Z_OK);
+
+    if (step)
+    {
+      printf("Simple fuzzy test: step %u total_succeeded: %u\n", step, total_succeeded);
+    }
+    else
+    {
+      if (cmp_status != Z_OK)
+      {
+        printf("uncompress failed!\n");
+        free(pCmp);
+        free(pUncomp);
+        return EXIT_FAILURE;
+      }
+
+      printf("Decompressed from %u to %u bytes\n", (mz_uint32)cmp_len, (mz_uint32)uncomp_len);
+
+      // Ensure uncompress() returned the expected data.
+      if ((uncomp_len != src_len) || (memcmp(pUncomp, s_pStr, (size_t)src_len)))
+      {
+        printf("Decompression failed!\n");
+        free(pCmp);
+        free(pUncomp);
+        return EXIT_FAILURE;
+      }
+    }
+
+    free(pCmp);
+    free(pUncomp);
+
+    step++;
+
+    // Keep on fuzzy testing if there's a non-empty command line.
+  } while (argc >= 2);
+
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example2.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example2.c
@@ -0,0 +1,164 @@
+// example2.c - Simple demonstration of miniz.c's ZIP archive API's.
+// Note this test deletes the test archive file "__mz_example2_test__.zip" in the current directory, then creates a new one with test data.
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+
+#if defined(__GNUC__)
+  // Ensure we get the 64-bit variants of the CRT's file I/O calls
+  #ifndef _FILE_OFFSET_BITS
+    #define _FILE_OFFSET_BITS 64
+  #endif
+  #ifndef _LARGEFILE64_SOURCE
+    #define _LARGEFILE64_SOURCE 1
+  #endif
+#endif
+
+#include <stdio.h>
+#include "miniz.h"
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+// The string to compress.
+static const char *s_pTest_str =
+  "MISSION CONTROL I wouldn't worry too much about the computer. First of all, there is still a chance that he is right, despite your tests, and" \
+  "if it should happen again, we suggest eliminating this possibility by allowing the unit to remain in place and seeing whether or not it" \
+  "actually fails. If the computer should turn out to be wrong, the situation is still not alarming. The type of obsessional error he may be" \
+  "guilty of is not unknown among the latest generation of HAL 9000 computers. It has almost always revolved around a single detail, such as" \
+  "the one you have described, and it has never interfered with the integrity or reliability of the computer's performance in other areas." \
+  "No one is certain of the cause of this kind of malfunctioning. It may be over-programming, but it could also be any number of reasons. In any" \
+  "event, it is somewhat analogous to human neurotic behavior. Does this answer your query?  Zero-five-three-Zero, MC, transmission concluded.";
+
+static const char *s_pComment = "This is a comment";
+
+int main(int argc, char *argv[])
+{
+  int i, sort_iter;
+  mz_bool status;
+  size_t uncomp_size;
+  mz_zip_archive zip_archive;
+  void *p;
+  const int N = 50;
+  char data[2048];
+  char archive_filename[64];
+  static const char *s_Test_archive_filename = "__mz_example2_test__.zip";
+
+  assert((strlen(s_pTest_str) + 64) < sizeof(data));
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  (void)argc, (void)argv;
+
+  // Delete the test archive, so it doesn't keep growing as we run this test
+  remove(s_Test_archive_filename);
+
+  // Append a bunch of text files to the test archive
+  for (i = (N - 1); i >= 0; --i)
+  {
+    sprintf(archive_filename, "%u.txt", i);
+    sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
+
+    // Add a new file to the archive. Note this is an IN-PLACE operation, so if it fails your archive is probably hosed (its central directory may not be complete) but it should be recoverable using zip -F or -FF. So use caution with this guy.
+    // A more robust way to add a file to an archive would be to read it into memory, perform the operation, then write a new archive out to a temp file and then delete/rename the files.
+    // Or, write a new archive to disk to a temp file, then delete/rename the files. For this test this API is fine.
+    status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, archive_filename, data, strlen(data) + 1, s_pComment, (uint16)strlen(s_pComment), MZ_BEST_COMPRESSION);
+    if (!status)
+    {
+      printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+
+  // Add a directory entry for testing
+  status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, "directory/", NULL, 0, "no comment", (uint16)strlen("no comment"), MZ_BEST_COMPRESSION);
+  if (!status)
+  {
+    printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Now try to open the archive.
+  memset(&zip_archive, 0, sizeof(zip_archive));
+
+  status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, 0);
+  if (!status)
+  {
+    printf("mz_zip_reader_init_file() failed!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Get and print information about each file in the archive.
+  for (i = 0; i < (int)mz_zip_reader_get_num_files(&zip_archive); i++)
+  {
+    mz_zip_archive_file_stat file_stat;
+    if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat))
+    {
+       printf("mz_zip_reader_file_stat() failed!\n");
+       mz_zip_reader_end(&zip_archive);
+       return EXIT_FAILURE;
+    }
+
+    printf("Filename: \"%s\", Comment: \"%s\", Uncompressed size: %u, Compressed size: %u, Is Dir: %u\n", file_stat.m_filename, file_stat.m_comment, (uint)file_stat.m_uncomp_size, (uint)file_stat.m_comp_size, mz_zip_reader_is_file_a_directory(&zip_archive, i));
+
+    if (!strcmp(file_stat.m_filename, "directory/"))
+    {
+      if (!mz_zip_reader_is_file_a_directory(&zip_archive, i))
+      {
+        printf("mz_zip_reader_is_file_a_directory() didn't return the expected results!\n");
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+    }
+  }
+
+  // Close the archive, freeing any resources it was using
+  mz_zip_reader_end(&zip_archive);
+
+  // Now verify the compressed data
+  for (sort_iter = 0; sort_iter < 2; sort_iter++)
+  {
+    memset(&zip_archive, 0, sizeof(zip_archive));
+    status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
+    if (!status)
+    {
+      printf("mz_zip_reader_init_file() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for (i = 0; i < N; i++)
+    {
+      sprintf(archive_filename, "%u.txt", i);
+      sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
+
+      // Try to extract all the files to the heap.
+      p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
+      if (!p)
+      {
+        printf("mz_zip_reader_extract_file_to_heap() failed!\n");
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+
+      // Make sure the extraction really succeeded.
+      if ((uncomp_size != (strlen(data) + 1)) || (memcmp(p, data, strlen(data))))
+      {
+        printf("mz_zip_reader_extract_file_to_heap() failed to extract the proper data\n");
+        mz_free(p);
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+
+      printf("Successfully extracted file \"%s\", size %u\n", archive_filename, (uint)uncomp_size);
+      printf("File data: \"%s\"\n", (const char *)p);
+
+      // We're done.
+      mz_free(p);
+    }
+
+    // Close the archive, freeing any resources it was using
+    mz_zip_reader_end(&zip_archive);
+  }
+
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example3.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example3.c
@@ -0,0 +1,269 @@
+// example3.c - Demonstrates how to use miniz.c's deflate() and inflate() functions for simple file compression.
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// For simplicity, this example is limited to files smaller than 4GB, but this is not a limitation of miniz.c.
+#include <stdio.h>
+#include <limits.h>
+#include "miniz.h"
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+#define BUF_SIZE (1024 * 1024)
+static uint8 s_inbuf[BUF_SIZE];
+static uint8 s_outbuf[BUF_SIZE];
+
+int main(int argc, char *argv[])
+{
+  const char *pMode;
+  FILE *pInfile, *pOutfile;
+  uint infile_size;
+  int level = Z_BEST_COMPRESSION;
+  z_stream stream;
+  int p = 1;
+  const char *pSrc_filename;
+  const char *pDst_filename;
+  long file_loc;
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  if (argc < 4)
+  {
+    printf("Usage: example3 [options] [mode:c or d] infile outfile\n");
+    printf("\nModes:\n");
+    printf("c - Compresses file infile to a zlib stream in file outfile\n");
+    printf("d - Decompress zlib stream in file infile to file outfile\n");
+    printf("\nOptions:\n");
+    printf("-l[0-10] - Compression level, higher values are slower.\n");
+    return EXIT_FAILURE;
+  }
+
+  while ((p < argc) && (argv[p][0] == '-'))
+  {
+    switch (argv[p][1])
+    {
+      case 'l':
+      {
+        level = atoi(&argv[1][2]);
+        if ((level < 0) || (level > 10))
+        {
+          printf("Invalid level!\n");
+          return EXIT_FAILURE;
+        }
+        break;
+      }
+      default:
+      {
+        printf("Invalid option: %s\n", argv[p]);
+        return EXIT_FAILURE;
+      }
+    }
+    p++;
+  }
+
+  if ((argc - p) < 3)
+  {
+    printf("Must specify mode, input filename, and output filename after options!\n");
+    return EXIT_FAILURE;
+  }
+  else if ((argc - p) > 3)
+  {
+    printf("Too many filenames!\n");
+    return EXIT_FAILURE;
+  }
+
+  pMode = argv[p++];
+  if (!strchr("cCdD", pMode[0]))
+  {
+    printf("Invalid mode!\n");
+    return EXIT_FAILURE;
+  }
+
+  pSrc_filename = argv[p++];
+  pDst_filename = argv[p++];
+
+  printf("Mode: %c, Level: %u\nInput File: \"%s\"\nOutput File: \"%s\"\n", pMode[0], level, pSrc_filename, pDst_filename);
+
+  // Open input file.
+  pInfile = fopen(pSrc_filename, "rb");
+  if (!pInfile)
+  {
+    printf("Failed opening input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Determine input file's size.
+  fseek(pInfile, 0, SEEK_END);
+  file_loc = ftell(pInfile);
+  fseek(pInfile, 0, SEEK_SET);
+
+  if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+  {
+     // This is not a limitation of miniz or tinfl, but this example.
+     printf("File is too large to be processed by this example.\n");
+     return EXIT_FAILURE;
+  }
+
+  infile_size = (uint)file_loc;
+
+  // Open output file.
+  pOutfile = fopen(pDst_filename, "wb");
+  if (!pOutfile)
+  {
+    printf("Failed opening output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Input file size: %u\n", infile_size);
+
+  // Init the z_stream
+  memset(&stream, 0, sizeof(stream));
+  stream.next_in = s_inbuf;
+  stream.avail_in = 0;
+  stream.next_out = s_outbuf;
+  stream.avail_out = BUF_SIZE;
+
+  if ((pMode[0] == 'c') || (pMode[0] == 'C'))
+  {
+    // Compression.
+    uint infile_remaining = infile_size;
+
+    if (deflateInit(&stream, level) != Z_OK)
+    {
+      printf("deflateInit() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for ( ; ; )
+    {
+      int status;
+      if (!stream.avail_in)
+      {
+        // Input buffer is empty, so read more bytes from input file.
+        uint n = my_min(BUF_SIZE, infile_remaining);
+
+        if (fread(s_inbuf, 1, n, pInfile) != n)
+        {
+          printf("Failed reading from input file!\n");
+          return EXIT_FAILURE;
+        }
+
+        stream.next_in = s_inbuf;
+        stream.avail_in = n;
+
+        infile_remaining -= n;
+        //printf("Input bytes remaining: %u\n", infile_remaining);
+      }
+
+      status = deflate(&stream, infile_remaining ? Z_NO_FLUSH : Z_FINISH);
+
+      if ((status == Z_STREAM_END) || (!stream.avail_out))
+      {
+        // Output buffer is full, or compression is done, so write buffer to output file.
+        uint n = BUF_SIZE - stream.avail_out;
+        if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+        {
+          printf("Failed writing to output file!\n");
+          return EXIT_FAILURE;
+        }
+        stream.next_out = s_outbuf;
+        stream.avail_out = BUF_SIZE;
+      }
+
+      if (status == Z_STREAM_END)
+        break;
+      else if (status != Z_OK)
+      {
+        printf("deflate() failed with status %i!\n", status);
+        return EXIT_FAILURE;
+      }
+    }
+
+    if (deflateEnd(&stream) != Z_OK)
+    {
+      printf("deflateEnd() failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+  else if ((pMode[0] == 'd') || (pMode[0] == 'D'))
+  {
+    // Decompression.
+    uint infile_remaining = infile_size;
+
+    if (inflateInit(&stream))
+    {
+      printf("inflateInit() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for ( ; ; )
+    {
+      int status;
+      if (!stream.avail_in)
+      {
+        // Input buffer is empty, so read more bytes from input file.
+        uint n = my_min(BUF_SIZE, infile_remaining);
+
+        if (fread(s_inbuf, 1, n, pInfile) != n)
+        {
+          printf("Failed reading from input file!\n");
+          return EXIT_FAILURE;
+        }
+
+        stream.next_in = s_inbuf;
+        stream.avail_in = n;
+
+        infile_remaining -= n;
+      }
+
+      status = inflate(&stream, Z_SYNC_FLUSH);
+
+      if ((status == Z_STREAM_END) || (!stream.avail_out))
+      {
+        // Output buffer is full, or decompression is done, so write buffer to output file.
+        uint n = BUF_SIZE - stream.avail_out;
+        if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+        {
+          printf("Failed writing to output file!\n");
+          return EXIT_FAILURE;
+        }
+        stream.next_out = s_outbuf;
+        stream.avail_out = BUF_SIZE;
+      }
+
+      if (status == Z_STREAM_END)
+        break;
+      else if (status != Z_OK)
+      {
+        printf("inflate() failed with status %i!\n", status);
+        return EXIT_FAILURE;
+      }
+    }
+
+    if (inflateEnd(&stream) != Z_OK)
+    {
+      printf("inflateEnd() failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+  else
+  {
+    printf("Invalid mode!\n");
+    return EXIT_FAILURE;
+  }
+
+  fclose(pInfile);
+  if (EOF == fclose(pOutfile))
+  {
+    printf("Failed writing to output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Total input bytes: %u\n", (mz_uint32)stream.total_in);
+  printf("Total output bytes: %u\n", (mz_uint32)stream.total_out);
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example4.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example4.c
@@ -0,0 +1,102 @@
+// example4.c - Uses tinfl.c to decompress a zlib stream in memory to an output file
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+#include "miniz.h"
+#include <stdio.h>
+#include <limits.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+static int tinfl_put_buf_func(const void* pBuf, int len, void *pUser)
+{
+  return len == (int)fwrite(pBuf, 1, len, (FILE*)pUser);
+}
+
+int main(int argc, char *argv[])
+{
+  int status;
+  FILE *pInfile, *pOutfile;
+  uint infile_size, outfile_size;
+  size_t in_buf_size;
+  uint8 *pCmp_data;
+  long file_loc;
+
+  if (argc != 3)
+  {
+    printf("Usage: example4 infile outfile\n");
+    printf("Decompresses zlib stream in file infile to file outfile.\n");
+    printf("Input file must be able to fit entirely in memory.\n");
+    printf("example3 can be used to create compressed zlib streams.\n");
+    return EXIT_FAILURE;
+  }
+
+  // Open input file.
+  pInfile = fopen(argv[1], "rb");
+  if (!pInfile)
+  {
+    printf("Failed opening input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Determine input file's size.
+  fseek(pInfile, 0, SEEK_END);
+  file_loc = ftell(pInfile);
+  fseek(pInfile, 0, SEEK_SET);
+
+  if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+  {
+     // This is not a limitation of miniz or tinfl, but this example.
+     printf("File is too large to be processed by this example.\n");
+     return EXIT_FAILURE;
+  }
+
+  infile_size = (uint)file_loc;
+
+  pCmp_data = (uint8 *)malloc(infile_size);
+  if (!pCmp_data)
+  {
+    printf("Out of memory!\n");
+    return EXIT_FAILURE;
+  }
+  if (fread(pCmp_data, 1, infile_size, pInfile) != infile_size)
+  {
+    printf("Failed reading input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Open output file.
+  pOutfile = fopen(argv[2], "wb");
+  if (!pOutfile)
+  {
+    printf("Failed opening output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Input file size: %u\n", infile_size);
+
+  in_buf_size = infile_size;
+  status = tinfl_decompress_mem_to_callback(pCmp_data, &in_buf_size, tinfl_put_buf_func, pOutfile, TINFL_FLAG_PARSE_ZLIB_HEADER);
+  if (!status)
+  {
+    printf("tinfl_decompress_mem_to_callback() failed with status %i!\n", status);
+    return EXIT_FAILURE;
+  }
+
+  outfile_size = ftell(pOutfile);
+
+  fclose(pInfile);
+  if (EOF == fclose(pOutfile))
+  {
+    printf("Failed writing to output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Total input bytes: %u\n", (uint)in_buf_size);
+  printf("Total output bytes: %u\n", outfile_size);
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example5.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example5.c
@@ -0,0 +1,327 @@
+// example5.c - Demonstrates how to use miniz.c's low-level tdefl_compress() and tinfl_inflate() API's for simple file to file compression/decompression.
+// The low-level API's are the fastest, make no use of dynamic memory allocation, and are the most flexible functions exposed by miniz.c.
+// Public domain, April 11 2012, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// For simplicity, this example is limited to files smaller than 4GB, but this is not a limitation of miniz.c.
+
+// Purposely disable a whole bunch of stuff this low-level example doesn't use.
+#define MINIZ_NO_STDIO
+#define MINIZ_NO_ARCHIVE_APIS
+#define MINIZ_NO_TIME
+#define MINIZ_NO_ZLIB_APIS
+#define MINIZ_NO_MALLOC
+#include "miniz.h"
+
+// Now include stdio.h because this test uses fopen(), etc. (but we still don't want miniz.c's stdio stuff, for testing).
+#include <stdio.h>
+#include <limits.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+// IN_BUF_SIZE is the size of the file read buffer.
+// IN_BUF_SIZE must be >= 1
+#define IN_BUF_SIZE (1024*512)
+static uint8 s_inbuf[IN_BUF_SIZE];
+
+// COMP_OUT_BUF_SIZE is the size of the output buffer used during compression.
+// COMP_OUT_BUF_SIZE must be >= 1 and <= OUT_BUF_SIZE
+#define COMP_OUT_BUF_SIZE (1024*512)
+
+// OUT_BUF_SIZE is the size of the output buffer used during decompression.
+// OUT_BUF_SIZE must be a power of 2 >= TINFL_LZ_DICT_SIZE (because the low-level decompressor not only writes, but reads from the output buffer as it decompresses)
+//#define OUT_BUF_SIZE (TINFL_LZ_DICT_SIZE)
+#define OUT_BUF_SIZE (1024*512)
+static uint8 s_outbuf[OUT_BUF_SIZE];
+
+// tdefl_compressor contains all the state needed by the low-level compressor so it's a pretty big struct (~300k).
+// This example makes it a global vs. putting it on the stack, of course in real-world usage you'll probably malloc() or new it.
+tdefl_compressor g_deflator;
+
+int main(int argc, char *argv[])
+{
+   const char *pMode;
+   FILE *pInfile, *pOutfile;
+   uint infile_size;
+   int level = 9;
+   int p = 1;
+   const char *pSrc_filename;
+   const char *pDst_filename;
+   const void *next_in = s_inbuf;
+   size_t avail_in = 0;
+   void *next_out = s_outbuf;
+   size_t avail_out = OUT_BUF_SIZE;
+   size_t total_in = 0, total_out = 0;
+   long file_loc;
+
+   assert(COMP_OUT_BUF_SIZE <= OUT_BUF_SIZE);
+
+   printf("miniz.c example5 (demonstrates tinfl/tdefl)\n");
+
+   if (argc < 4)
+   {
+      printf("File to file compression/decompression using the low-level tinfl/tdefl API's.\n");
+      printf("Usage: example5 [options] [mode:c or d] infile outfile\n");
+      printf("\nModes:\n");
+      printf("c - Compresses file infile to a zlib stream in file outfile\n");
+      printf("d - Decompress zlib stream in file infile to file outfile\n");
+      printf("\nOptions:\n");
+      printf("-l[0-10] - Compression level, higher values are slower, 0 is none.\n");
+      return EXIT_FAILURE;
+   }
+
+   while ((p < argc) && (argv[p][0] == '-'))
+   {
+      switch (argv[p][1])
+      {
+         case 'l':
+         {
+            level = atoi(&argv[1][2]);
+            if ((level < 0) || (level > 10))
+            {
+               printf("Invalid level!\n");
+               return EXIT_FAILURE;
+            }
+            break;
+         }
+         default:
+         {
+            printf("Invalid option: %s\n", argv[p]);
+            return EXIT_FAILURE;
+         }
+      }
+      p++;
+   }
+
+   if ((argc - p) < 3)
+   {
+      printf("Must specify mode, input filename, and output filename after options!\n");
+      return EXIT_FAILURE;
+   }
+   else if ((argc - p) > 3)
+   {
+      printf("Too many filenames!\n");
+      return EXIT_FAILURE;
+   }
+
+   pMode = argv[p++];
+   if (!strchr("cCdD", pMode[0]))
+   {
+      printf("Invalid mode!\n");
+      return EXIT_FAILURE;
+   }
+
+   pSrc_filename = argv[p++];
+   pDst_filename = argv[p++];
+
+   printf("Mode: %c, Level: %u\nInput File: \"%s\"\nOutput File: \"%s\"\n", pMode[0], level, pSrc_filename, pDst_filename);
+
+   // Open input file.
+   pInfile = fopen(pSrc_filename, "rb");
+   if (!pInfile)
+   {
+      printf("Failed opening input file!\n");
+      return EXIT_FAILURE;
+   }
+
+   // Determine input file's size.
+   fseek(pInfile, 0, SEEK_END);
+   file_loc = ftell(pInfile);
+   fseek(pInfile, 0, SEEK_SET);
+
+   if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+   {
+      // This is not a limitation of miniz or tinfl, but this example.
+      printf("File is too large to be processed by this example.\n");
+      return EXIT_FAILURE;
+   }
+
+   infile_size = (uint)file_loc;
+
+   // Open output file.
+   pOutfile = fopen(pDst_filename, "wb");
+   if (!pOutfile)
+   {
+      printf("Failed opening output file!\n");
+      return EXIT_FAILURE;
+   }
+
+   printf("Input file size: %u\n", infile_size);
+
+   if ((pMode[0] == 'c') || (pMode[0] == 'C'))
+   {
+      // The number of dictionary probes to use at each compression level (0-10). 0=implies fastest/minimal possible probing.
+      static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32,  16, 32, 128, 256,  512, 768, 1500 };
+
+      tdefl_status status;
+      uint infile_remaining = infile_size;
+
+      // create tdefl() compatible flags (we have to compose the low-level flags ourselves, or use tdefl_create_comp_flags_from_zip_params() but that means MINIZ_NO_ZLIB_APIS can't be defined).
+      mz_uint comp_flags = TDEFL_WRITE_ZLIB_HEADER | s_tdefl_num_probes[MZ_MIN(10, level)] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
+      if (!level)
+         comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
+
+      // Initialize the low-level compressor.
+      status = tdefl_init(&g_deflator, NULL, NULL, comp_flags);
+      if (status != TDEFL_STATUS_OKAY)
+      {
+         printf("tdefl_init() failed!\n");
+         return EXIT_FAILURE;
+      }
+
+      avail_out = COMP_OUT_BUF_SIZE;
+
+      // Compression.
+      for ( ; ; )
+      {
+         size_t in_bytes, out_bytes;
+
+         if (!avail_in)
+         {
+            // Input buffer is empty, so read more bytes from input file.
+            uint n = my_min(IN_BUF_SIZE, infile_remaining);
+
+            if (fread(s_inbuf, 1, n, pInfile) != n)
+            {
+               printf("Failed reading from input file!\n");
+               return EXIT_FAILURE;
+            }
+
+            next_in = s_inbuf;
+            avail_in = n;
+
+            infile_remaining -= n;
+            //printf("Input bytes remaining: %u\n", infile_remaining);
+         }
+
+         in_bytes = avail_in;
+         out_bytes = avail_out;
+         // Compress as much of the input as possible (or all of it) to the output buffer.
+         status = tdefl_compress(&g_deflator, next_in, &in_bytes, next_out, &out_bytes, infile_remaining ? TDEFL_NO_FLUSH : TDEFL_FINISH);
+
+         next_in = (const char *)next_in + in_bytes;
+         avail_in -= in_bytes;
+         total_in += in_bytes;
+
+         next_out = (char *)next_out + out_bytes;
+         avail_out -= out_bytes;
+         total_out += out_bytes;
+
+         if ((status != TDEFL_STATUS_OKAY) || (!avail_out))
+         {
+            // Output buffer is full, or compression is done or failed, so write buffer to output file.
+            uint n = COMP_OUT_BUF_SIZE - (uint)avail_out;
+            if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+            {
+               printf("Failed writing to output file!\n");
+               return EXIT_FAILURE;
+            }
+            next_out = s_outbuf;
+            avail_out = COMP_OUT_BUF_SIZE;
+         }
+
+         if (status == TDEFL_STATUS_DONE)
+         {
+            // Compression completed successfully.
+            break;
+         }
+         else if (status != TDEFL_STATUS_OKAY)
+         {
+            // Compression somehow failed.
+            printf("tdefl_compress() failed with status %i!\n", status);
+            return EXIT_FAILURE;
+         }
+      }
+   }
+   else if ((pMode[0] == 'd') || (pMode[0] == 'D'))
+   {
+      // Decompression.
+      uint infile_remaining = infile_size;
+
+      tinfl_decompressor inflator;
+      tinfl_init(&inflator);
+
+      for ( ; ; )
+      {
+         size_t in_bytes, out_bytes;
+         tinfl_status status;
+         if (!avail_in)
+         {
+            // Input buffer is empty, so read more bytes from input file.
+            uint n = my_min(IN_BUF_SIZE, infile_remaining);
+
+            if (fread(s_inbuf, 1, n, pInfile) != n)
+            {
+               printf("Failed reading from input file!\n");
+               return EXIT_FAILURE;
+            }
+
+            next_in = s_inbuf;
+            avail_in = n;
+
+            infile_remaining -= n;
+         }
+
+         in_bytes = avail_in;
+         out_bytes = avail_out;
+         status = tinfl_decompress(&inflator, (const mz_uint8 *)next_in, &in_bytes, s_outbuf, (mz_uint8 *)next_out, &out_bytes, (infile_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0) | TINFL_FLAG_PARSE_ZLIB_HEADER);
+
+         avail_in -= in_bytes;
+         next_in = (const mz_uint8 *)next_in + in_bytes;
+         total_in += in_bytes;
+
+         avail_out -= out_bytes;
+         next_out = (mz_uint8 *)next_out + out_bytes;
+         total_out += out_bytes;
+
+         if ((status <= TINFL_STATUS_DONE) || (!avail_out))
+         {
+            // Output buffer is full, or decompression is done, so write buffer to output file.
+            uint n = OUT_BUF_SIZE - (uint)avail_out;
+            if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+            {
+               printf("Failed writing to output file!\n");
+               return EXIT_FAILURE;
+            }
+            next_out = s_outbuf;
+            avail_out = OUT_BUF_SIZE;
+         }
+
+         // If status is <= TINFL_STATUS_DONE then either decompression is done or something went wrong.
+         if (status <= TINFL_STATUS_DONE)
+         {
+            if (status == TINFL_STATUS_DONE)
+            {
+               // Decompression completed successfully.
+               break;
+            }
+            else
+            {
+               // Decompression failed.
+               printf("tinfl_decompress() failed with status %i!\n", status);
+               return EXIT_FAILURE;
+            }
+         }
+      }
+   }
+   else
+   {
+      printf("Invalid mode!\n");
+      return EXIT_FAILURE;
+   }
+
+   fclose(pInfile);
+   if (EOF == fclose(pOutfile))
+   {
+      printf("Failed writing to output file!\n");
+      return EXIT_FAILURE;
+   }
+
+   printf("Total input bytes: %u\n", (mz_uint32)total_in);
+   printf("Total output bytes: %u\n", (mz_uint32)total_out);
+   printf("Success.\n");
+   return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example6.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example6.c
@@ -0,0 +1,166 @@
+// example6.c - Demonstrates how to miniz's PNG writer func
+// Public domain, April 11 2012, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// Mandlebrot set code from http://rosettacode.org/wiki/Mandelbrot_set#C
+// Must link this example against libm on Linux.
+
+// Purposely disable a whole bunch of stuff this low-level example doesn't use.
+#define MINIZ_NO_STDIO
+#define MINIZ_NO_TIME
+#define MINIZ_NO_ZLIB_APIS
+#include "miniz.h"
+
+// Now include stdio.h because this test uses fopen(), etc. (but we still don't want miniz.c's stdio stuff, for testing).
+#include <stdio.h>
+#include <limits.h>
+#include <math.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+typedef struct
+{
+  uint8 r, g, b;
+} rgb_t;
+
+static void hsv_to_rgb(int hue, int min, int max, rgb_t *p)
+{
+  const int invert = 0;
+  const int saturation = 1;
+  const int color_rotate = 0;
+
+  if (min == max) max = min + 1;
+  if (invert) hue = max - (hue - min);
+  if (!saturation) {
+    p->r = p->g = p->b = 255 * (max - hue) / (max - min);
+    return;
+  } else {
+    const double h_dbl = fmod(color_rotate + 1e-4 + 4.0 * (hue - min) / (max - min), 6);
+    const double c_dbl = 255 * saturation;
+    const double X_dbl = c_dbl * (1 - fabs(fmod(h_dbl, 2) - 1));
+    const int h = (int)h_dbl;
+    const int c = (int)c_dbl;
+    const int X = (int)X_dbl;
+
+    p->r = p->g = p->b = 0;
+
+    switch(h) {
+    case 0: p->r = c; p->g = X; return;
+    case 1:	p->r = X; p->g = c; return;
+    case 2: p->g = c; p->b = X; return;
+    case 3: p->g = X; p->b = c; return;
+    case 4: p->r = X; p->b = c; return;
+    default:p->r = c; p->b = X;
+    }
+  }
+}
+
+int main(int argc, char *argv[])
+{
+  // Image resolution
+  const int iXmax = 4096;
+  const int iYmax = 4096;
+
+  // Output filename
+  static const char *pFilename = "mandelbrot.png";
+
+  int iX, iY;
+  const double CxMin = -2.5;
+  const double CxMax = 1.5;
+  const double CyMin = -2.0;
+  const double CyMax = 2.0;
+
+  double PixelWidth = (CxMax - CxMin) / iXmax;
+  double PixelHeight = (CyMax - CyMin) / iYmax;
+
+  // Z=Zx+Zy*i  ;   Z0 = 0
+  double Zx, Zy;
+  double Zx2, Zy2; // Zx2=Zx*Zx;  Zy2=Zy*Zy
+
+  int Iteration;
+  const int IterationMax = 200;
+
+  // bail-out value , radius of circle
+  const double EscapeRadius = 2;
+  double ER2=EscapeRadius * EscapeRadius;
+
+  uint8 *pImage = (uint8 *)malloc(iXmax * 3 * iYmax);
+
+  // world ( double) coordinate = parameter plane
+  double Cx,Cy;
+
+  int MinIter = 9999, MaxIter = 0;
+
+  (void)argc, (void)argv;
+
+  for(iY = 0; iY < iYmax; iY++)
+  {
+    Cy = CyMin + iY * PixelHeight;
+    if (fabs(Cy) < PixelHeight/2)
+      Cy = 0.0; // Main antenna
+
+    for(iX = 0; iX < iXmax; iX++)
+    {
+      uint8 *color = pImage + (iX * 3) + (iY * iXmax * 3);
+
+      Cx = CxMin + iX * PixelWidth;
+
+      // initial value of orbit = critical point Z= 0
+      Zx = 0.0;
+      Zy = 0.0;
+      Zx2 = Zx * Zx;
+      Zy2 = Zy * Zy;
+
+      for (Iteration=0;Iteration<IterationMax && ((Zx2+Zy2)<ER2);Iteration++)
+      {
+        Zy = 2 * Zx * Zy + Cy;
+        Zx =Zx2 - Zy2 + Cx;
+        Zx2 = Zx * Zx;
+        Zy2 = Zy * Zy;
+      };
+
+      color[0] = (uint8)Iteration;
+      color[1] = (uint8)Iteration >> 8;
+      color[2] = 0;
+
+      if (Iteration < MinIter)
+        MinIter = Iteration;
+      if (Iteration > MaxIter)
+        MaxIter = Iteration;
+    }
+  }
+
+  for(iY = 0; iY < iYmax; iY++)
+  {
+    for(iX = 0; iX < iXmax; iX++)
+    {
+      uint8 *color = (uint8 *)(pImage + (iX * 3) + (iY * iXmax * 3));
+
+      uint Iterations = color[0] | (color[1] << 8U);
+
+      hsv_to_rgb((int)Iterations, MinIter, MaxIter, (rgb_t *)color);
+    }
+  }
+
+  // Now write the PNG image.
+  {
+    size_t png_data_size = 0;
+    void *pPNG_data = tdefl_write_image_to_png_file_in_memory_ex(pImage, iXmax, iYmax, 3, &png_data_size, 6, MZ_FALSE);
+    if (!pPNG_data)
+      fprintf(stderr, "tdefl_write_image_to_png_file_in_memory_ex() failed!\n");
+    else
+    {
+      FILE *pFile = fopen(pFilename, "wb");
+      fwrite(pPNG_data, 1, png_data_size, pFile);
+      fclose(pFile);
+      printf("Wrote %s\n", pFilename);
+    }
+
+    // mz_free() is by default just an alias to free() internally, but if you've overridden miniz's allocation funcs you'll probably need to call mz_free().
+    mz_free(pPNG_data);
+  }
+
+  free(pImage);
+
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/miniz.c
+++ b/code/components/jomjol_fileserver_ota/miniz/miniz.c
--- a/code/components/jomjol_fileserver_ota/miniz/miniz.h
+++ b/code/components/jomjol_fileserver_ota/miniz/miniz.h
@@ -1,4 +1,7 @@
-/* miniz.c 2.1.0 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
+#ifndef MINIZ_EXPORT
+#define MINIZ_EXPORT
+#endif
+/* miniz.c 3.0.0 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
   See "unlicense" statement at the end of this file.
   Rich Geldreich <richgel99@gmail.com>, last updated Oct. 13, 2013
   Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
@@ -95,7 +98,7 @@
     possibility that the archive's central directory could be lost with this method if anything goes wrong, though.

     - ZIP archive support limitations:
-     No zip64 or spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
+     No spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
     Requires streams capable of seeking.

   * This is a header file library, like stb_image.c. To get only a header file, either cut and paste the
@@ -114,10 +117,8 @@



-
-
 /* Defines to completely disable specific portions of miniz.c: 
-   If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl. */
+   If all macros here are defined the only functionality remaining will be CRC-32 and adler-32. */

 /* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O. */
 /*#define MINIZ_NO_STDIO */
@@ -127,6 +128,12 @@
 /* The current downside is the times written to your archives will be from 1979. */
 /*#define MINIZ_NO_TIME */

+/* Define MINIZ_NO_DEFLATE_APIS to disable all compression API's. */
+/*#define MINIZ_NO_DEFLATE_APIS */
+
+/* Define MINIZ_NO_INFLATE_APIS to disable all decompression API's. */
+/*#define MINIZ_NO_INFLATE_APIS */
+
 /* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */
 /*#define MINIZ_NO_ARCHIVE_APIS */

@@ -145,6 +152,14 @@
   functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. */
 /*#define MINIZ_NO_MALLOC */

+#ifdef MINIZ_NO_INFLATE_APIS
+//#define MINIZ_NO_ARCHIVE_APIS
+#endif
+
+#ifdef MINIZ_NO_DEFLATE_APIS
+#define MINIZ_NO_ARCHIVE_WRITING_APIS
+#endif
+
 #if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
 /* TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc on Linux */
 #define MINIZ_NO_TIME
@@ -163,18 +178,40 @@
 #define MINIZ_X86_OR_X64_CPU 0
 #endif

-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
+/* Set MINIZ_LITTLE_ENDIAN only if not set */
+#if !defined(MINIZ_LITTLE_ENDIAN)
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
+
+#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
 /* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */
 #define MINIZ_LITTLE_ENDIAN 1
 #else
 #define MINIZ_LITTLE_ENDIAN 0
 #endif

+#else
+
+#if MINIZ_X86_OR_X64_CPU
+#define MINIZ_LITTLE_ENDIAN 1
+#else
+#define MINIZ_LITTLE_ENDIAN 0
+#endif
+
+#endif
+#endif
+
+/* Using unaligned loads and stores causes errors when using UBSan */
+#if defined(__has_feature)
+#if __has_feature(undefined_behavior_sanitizer)
+#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
+#endif
+#endif
+
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */
 #if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES)
 #if MINIZ_X86_OR_X64_CPU
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
+#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
 #define MINIZ_UNALIGNED_USE_MEMCPY
 #else
 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
@@ -198,15 +235,15 @@ extern "C" {
 typedef unsigned long mz_ulong;

 /* mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap. */
-void mz_free(void *p);
+MINIZ_EXPORT void mz_free(void *p);

 #define MZ_ADLER32_INIT (1)
 /* mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL. */
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
+MINIZ_EXPORT mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);

 #define MZ_CRC32_INIT (0)
 /* mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL. */
-mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
+MINIZ_EXPORT mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);

 /* Compression strategies. */
 enum
@@ -222,7 +259,7 @@ enum
 #define MZ_DEFLATED 8

 /* Heap allocation callbacks.
-Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long. */
+Note that mz_alloc_func parameter types purposely differ from zlib's: items/size is size_t, not unsigned long. */
 typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
 typedef void (*mz_free_func)(void *opaque, void *address);
 typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);
@@ -238,9 +275,9 @@ enum
    MZ_DEFAULT_COMPRESSION = -1
 };

-#define MZ_VERSION "10.1.0"
-#define MZ_VERNUM 0xA100
-#define MZ_VER_MAJOR 10
+#define MZ_VERSION "11.0.1"
+#define MZ_VERNUM 0xB001
+#define MZ_VER_MAJOR 11
 #define MZ_VER_MINOR 1
 #define MZ_VER_REVISION 0
 #define MZ_VER_SUBREVISION 0
@@ -304,7 +341,9 @@ typedef struct mz_stream_s
 typedef mz_stream *mz_streamp;

 /* Returns the version string of miniz.c. */
-const char *mz_version(void);
+MINIZ_EXPORT const char *mz_version(void);
+
+#ifndef MINIZ_NO_DEFLATE_APIS

 /* mz_deflateInit() initializes a compressor with default options: */
 /* Parameters: */
@@ -317,17 +356,17 @@ const char *mz_version(void);
 /*  MZ_STREAM_ERROR if the stream is bogus. */
 /*  MZ_PARAM_ERROR if the input parameters are bogus. */
 /*  MZ_MEM_ERROR on out of memory. */
-int mz_deflateInit(mz_streamp pStream, int level);
+MINIZ_EXPORT int mz_deflateInit(mz_streamp pStream, int level);

 /* mz_deflateInit2() is like mz_deflate(), except with more control: */
 /* Additional parameters: */
 /*   method must be MZ_DEFLATED */
 /*   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer) */
 /*   mem_level must be between [1, 9] (it's checked but ignored by miniz.c) */
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
+MINIZ_EXPORT int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);

 /* Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). */
-int mz_deflateReset(mz_streamp pStream);
+MINIZ_EXPORT int mz_deflateReset(mz_streamp pStream);

 /* mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible. */
 /* Parameters: */
@@ -339,34 +378,38 @@ int mz_deflateReset(mz_streamp pStream);
 /*   MZ_STREAM_ERROR if the stream is bogus. */
 /*   MZ_PARAM_ERROR if one of the parameters is invalid. */
 /*   MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.) */
-int mz_deflate(mz_streamp pStream, int flush);
+MINIZ_EXPORT int mz_deflate(mz_streamp pStream, int flush);

 /* mz_deflateEnd() deinitializes a compressor: */
 /* Return values: */
 /*  MZ_OK on success. */
 /*  MZ_STREAM_ERROR if the stream is bogus. */
-int mz_deflateEnd(mz_streamp pStream);
+MINIZ_EXPORT int mz_deflateEnd(mz_streamp pStream);

 /* mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH. */
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
+MINIZ_EXPORT mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);

 /* Single-call compression functions mz_compress() and mz_compress2(): */
 /* Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure. */
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
+MINIZ_EXPORT int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);

 /* mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress(). */
-mz_ulong mz_compressBound(mz_ulong source_len);
+MINIZ_EXPORT mz_ulong mz_compressBound(mz_ulong source_len);
+
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+
+#ifndef MINIZ_NO_INFLATE_APIS

 /* Initializes a decompressor. */
-int mz_inflateInit(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateInit(mz_streamp pStream);

 /* mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer: */
 /* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). */
-int mz_inflateInit2(mz_streamp pStream, int window_bits);
+MINIZ_EXPORT int mz_inflateInit2(mz_streamp pStream, int window_bits);

 /* Quickly resets a compressor without having to reallocate anything. Same as calling mz_inflateEnd() followed by mz_inflateInit()/mz_inflateInit2(). */
-int mz_inflateReset(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateReset(mz_streamp pStream);

 /* Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible. */
 /* Parameters: */
@@ -382,17 +425,19 @@ int mz_inflateReset(mz_streamp pStream);
 /*   MZ_PARAM_ERROR if one of the parameters is invalid. */
 /*   MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again */
 /*   with more input data, or with more room in the output buffer (except when using single call decompression, described above). */
-int mz_inflate(mz_streamp pStream, int flush);
+MINIZ_EXPORT int mz_inflate(mz_streamp pStream, int flush);

 /* Deinitializes a decompressor. */
-int mz_inflateEnd(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateEnd(mz_streamp pStream);

 /* Single-call decompression. */
 /* Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure. */
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len);
+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/

 /* Returns a string description of the specified error code, or NULL if the error code is invalid. */
-const char *mz_error(int err);
+MINIZ_EXPORT const char *mz_error(int err);

 /* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports. */
 /* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project. */
@@ -440,6 +485,8 @@ typedef void *const voidpc;
 #define free_func mz_free_func
 #define internal_state mz_internal_state
 #define z_stream mz_stream
+
+#ifndef MINIZ_NO_DEFLATE_APIS
 #define deflateInit mz_deflateInit
 #define deflateInit2 mz_deflateInit2
 #define deflateReset mz_deflateReset
@@ -449,12 +496,18 @@ typedef void *const voidpc;
 #define compress mz_compress
 #define compress2 mz_compress2
 #define compressBound mz_compressBound
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+
+#ifndef MINIZ_NO_INFLATE_APIS
 #define inflateInit mz_inflateInit
 #define inflateInit2 mz_inflateInit2
 #define inflateReset mz_inflateReset
 #define inflate mz_inflate
 #define inflateEnd mz_inflateEnd
 #define uncompress mz_uncompress
+#define uncompress2 mz_uncompress2
+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
+
 #define crc32 mz_crc32
 #define adler32 mz_adler32
 #define MAX_WBITS 15
@@ -475,12 +528,19 @@ typedef void *const voidpc;
 #ifdef __cplusplus
 }
 #endif
+
+
+
+
+
 #pragma once
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>

+
+
 /* ------------------- Types and macros */
 typedef unsigned char mz_uint8;
 typedef signed short mz_int16;
@@ -511,7 +571,8 @@ typedef int mz_bool;
 #ifdef MINIZ_NO_TIME
 typedef struct mz_dummy_time_t_tag
 {
-    int m_dummy;
+    mz_uint32 m_dummy1;
+    mz_uint32 m_dummy2;
 } mz_dummy_time_t;
 #define MZ_TIME_T mz_dummy_time_t
 #else
@@ -533,6 +594,8 @@ typedef struct mz_dummy_time_t_tag
 #define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
 #define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
+#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
+#define MZ_CLEAR_PTR(obj) memset((obj), 0, sizeof(*obj))

 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
 #define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
@@ -556,9 +619,9 @@ typedef struct mz_dummy_time_t_tag
 extern "C" {
 #endif

-extern void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
-extern void miniz_def_free_func(void *opaque, void *address);
-extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);
+extern MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
+extern MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address);
+extern MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);

 #define MZ_UINT16_MAX (0xFFFFU)
 #define MZ_UINT32_MAX (0xFFFFFFFFU)
@@ -566,9 +629,11 @@ extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, s
 #ifdef __cplusplus
 }
 #endif
-#pragma once
+ #pragma once


+#ifndef MINIZ_NO_DEFLATE_APIS
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -616,11 +681,11 @@ enum
 /*  Function returns a pointer to the compressed data, or NULL on failure. */
 /*  *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data. */
 /*  The caller must free() the returned block when it's no longer needed. */
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
+MINIZ_EXPORT void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);

 /* tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory. */
 /* Returns 0 on failure. */
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
+MINIZ_EXPORT size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);

 /* Compresses an image to a compressed PNG file in memory. */
 /* On entry: */
@@ -632,14 +697,14 @@ size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void
 /*  Function returns a pointer to the compressed data, or NULL on failure. */
 /*  *pLen_out will be set to the size of the PNG image file. */
 /*  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);
+MINIZ_EXPORT void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
+MINIZ_EXPORT void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);

 /* Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. */
 typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);

 /* tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally. */
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 enum
 {
@@ -727,39 +792,43 @@ typedef struct
 /* pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression. */
 /* If pBut_buf_func is NULL the user should always call the tdefl_compress() API. */
 /* flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.) */
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 /* Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible. */
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
+MINIZ_EXPORT tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);

 /* tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr. */
 /* tdefl_compress_buffer() always consumes the entire input buffer. */
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
+MINIZ_EXPORT tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);

-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
+MINIZ_EXPORT tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
+MINIZ_EXPORT mz_uint32 tdefl_get_adler32(tdefl_compressor *d);

 /* Create tdefl_compress() flags given zlib-style compression parameters. */
 /* level may range from [0,10] (where 10 is absolute max compression, but may be much slower on some files) */
 /* window_bits may be -15 (raw deflate) or 15 (zlib) */
 /* strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);
+MINIZ_EXPORT mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);

 #ifndef MINIZ_NO_MALLOC
 /* Allocate the tdefl_compressor structure in C so that */
 /* non-C language bindings to tdefl_ API don't need to worry about */
 /* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc(void);
-void tdefl_compressor_free(tdefl_compressor *pComp);
+MINIZ_EXPORT tdefl_compressor *tdefl_compressor_alloc(void);
+MINIZ_EXPORT void tdefl_compressor_free(tdefl_compressor *pComp);
 #endif

 #ifdef __cplusplus
 }
 #endif
-#pragma once
+
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+ #pragma once

 /* ------------------- Low-level Decompression API Definitions */

+#ifndef MINIZ_NO_INFLATE_APIS
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -784,17 +853,17 @@ enum
 /*  Function returns a pointer to the decompressed data, or NULL on failure. */
 /*  *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data. */
 /*  The caller must call mz_free() on the returned block when it's no longer needed. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
+MINIZ_EXPORT void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);

 /* tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory. */
 /* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success. */
 #define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
+MINIZ_EXPORT size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);

 /* tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer. */
 /* Returns 1 on success or 0 on failure. */
 typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 struct tinfl_decompressor_tag;
 typedef struct tinfl_decompressor_tag tinfl_decompressor;
@@ -803,8 +872,8 @@ typedef struct tinfl_decompressor_tag tinfl_decompressor;
 /* Allocate the tinfl_decompressor structure in C so that */
 /* non-C language bindings to tinfl_ API don't need to worry about */
 /* structure size and allocation mechanism. */
-tinfl_decompressor *tinfl_decompressor_alloc(void);
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
+MINIZ_EXPORT tinfl_decompressor *tinfl_decompressor_alloc(void);
+MINIZ_EXPORT void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
 #endif

 /* Max size of LZ dictionary. */
@@ -855,7 +924,7 @@ typedef enum {

 /* Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability. */
 /* This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. */
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
+MINIZ_EXPORT tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);

 /* Internal/private bits follow. */
 enum
@@ -868,12 +937,6 @@ enum
    TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
 };

-typedef struct
-{
-    mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
-    mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
-} tinfl_huff_table;
-
 #if MINIZ_HAS_64BIT_REGISTERS
 #define TINFL_USE_64BIT_BITBUF 1
 #else
@@ -893,7 +956,13 @@ struct tinfl_decompressor_tag
    mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
    tinfl_bit_buf_t m_bit_buf;
    size_t m_dist_from_out_buf_start;
-    tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
+    mz_int16 m_look_up[TINFL_MAX_HUFF_TABLES][TINFL_FAST_LOOKUP_SIZE];
+    mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
+    mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 * 2];
+    mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 * 2];
+    mz_uint8 m_code_size_0[TINFL_MAX_HUFF_SYMBOLS_0];
+    mz_uint8 m_code_size_1[TINFL_MAX_HUFF_SYMBOLS_1];
+    mz_uint8 m_code_size_2[TINFL_MAX_HUFF_SYMBOLS_2];
    mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
 };

@@ -901,6 +970,8 @@ struct tinfl_decompressor_tag
 }
 #endif

+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
+ 
 #pragma once


@@ -934,10 +1005,6 @@ typedef struct
    mz_uint16 m_bit_flag;
    mz_uint16 m_method;

-#ifndef MINIZ_NO_TIME
-    MZ_TIME_T m_time;
-#endif
-
    /* CRC-32 of uncompressed data. */
    mz_uint32 m_crc32;

@@ -974,6 +1041,11 @@ typedef struct
    /* Guaranteed to be zero terminated, may be truncated to fit. */
    char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE];

+#ifdef MINIZ_NO_TIME
+    MZ_TIME_T m_padding;
+#else
+    MZ_TIME_T m_time;
+#endif
 } mz_zip_archive_file_stat;

 typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n);
@@ -999,7 +1071,10 @@ typedef enum {
    MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000,     /* validate the local headers, but don't decompress the entire file and check the crc32 */
    MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000,               /* always use the zip64 file format, instead of the original zip file format with automatic switch to zip64. Use as flags parameter with mz_zip_writer_init*_v2 */
    MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000,
-    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000
+    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000,
+    /*After adding a compressed file, seek back
+    to local file header and set the correct sizes*/
+    MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE = 0x20000
 } mz_zip_flags;

 typedef enum {
@@ -1082,9 +1157,7 @@ typedef struct
    mz_uint flags;

    int status;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    mz_uint file_crc32;
-#endif
+
    mz_uint64 read_buf_size, read_buf_ofs, read_buf_avail, comp_remaining, out_buf_ofs, cur_file_ofs;
    mz_zip_archive_file_stat file_stat;
    void *pRead_buf;
@@ -1094,149 +1167,157 @@ typedef struct

    tinfl_decompressor inflator;

+#ifdef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
+    mz_uint padding;
+#else
+    mz_uint file_crc32;
+#endif
+
 } mz_zip_reader_extract_iter_state;

 /* -------- ZIP reading */

 /* Inits a ZIP archive reader. */
 /* These functions read and validate the archive's central directory. */
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);

-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);

 #ifndef MINIZ_NO_STDIO
 /* Read a archive from a disk file. */
 /* file_start_ofs is the file offset where the archive actually begins, or 0. */
 /* actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive. */
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);

 /* Read an archive from an already opened FILE, beginning at the current file position. */
-/* The archive is assumed to be archive_size bytes long. If archive_size is < 0, then the entire rest of the file is assumed to contain the archive. */
+/* The archive is assumed to be archive_size bytes long. If archive_size is 0, then the entire rest of the file is assumed to contain the archive. */
 /* The FILE will NOT be closed when mz_zip_reader_end() is called. */
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
 #endif

 /* Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used. */
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_reader_end(mz_zip_archive *pZip);

 /* -------- ZIP reading or writing */

 /* Clears a mz_zip_archive struct to all zeros. */
 /* Important: This must be done before passing the struct to any mz_zip functions. */
-void mz_zip_zero_struct(mz_zip_archive *pZip);
+MINIZ_EXPORT void mz_zip_zero_struct(mz_zip_archive *pZip);

-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);

 /* Returns the total number of files in the archive. */
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);

-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
+MINIZ_EXPORT MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);

 /* Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. */
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);
+MINIZ_EXPORT size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);

 /* All mz_zip funcs set the m_last_error field in the mz_zip_archive struct. These functions retrieve/manipulate this field. */
 /* Note that the m_last_error functionality is not thread safe. */
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
-const char *mz_zip_get_error_string(mz_zip_error mz_err);
+MINIZ_EXPORT mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
+MINIZ_EXPORT mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT const char *mz_zip_get_error_string(mz_zip_error mz_err);

 /* MZ_TRUE if the archive file entry is a directory entry. */
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);

 /* MZ_TRUE if the file is encrypted/strong encrypted. */
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);

 /* MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file. */
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);

 /* Retrieves the filename of an archive file entry. */
 /* Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename. */
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);
+MINIZ_EXPORT mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);

 /* Attempts to locates a file in the archive's central directory. */
 /* Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH */
 /* Returns -1 if the file cannot be found. */
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-int mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);
+MINIZ_EXPORT int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);

 /* Returns detailed information about an archive file entry. */
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);
+MINIZ_EXPORT mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);

 /* MZ_TRUE if the file is in zip64 format. */
 /* A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);

 /* Returns the total central directory size in bytes. */
 /* The current max supported size is <= MZ_UINT32_MAX. */
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);
+MINIZ_EXPORT size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);

 /* Extracts a archive file to a memory buffer using no memory allocation. */
 /* There must be at least enough room on the stack to store the inflator's state (~34KB or so). */
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);

 /* Extracts a archive file to a memory buffer. */
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);

 /* Extracts a archive file to a dynamically allocated heap buffer. */
 /* The memory will be allocated via the mz_zip_archive's alloc/realloc functions. */
 /* Returns NULL and sets the last error on failure. */
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);

 /* Extracts a archive file using a callback function to output the file's data. */
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);

 /* Extract a file iteratively */
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);
+MINIZ_EXPORT mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
+MINIZ_EXPORT mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
+MINIZ_EXPORT size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);

 #ifndef MINIZ_NO_STDIO
 /* Extracts a archive file to a disk file and sets its last accessed and modified times. */
 /* This function only extracts files, not archive directory records. */
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);

 /* Extracts a archive file starting at the current position in the destination FILE stream. */
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
 #endif

 #if 0
 /* TODO */
 	typedef void *mz_zip_streaming_extract_state_ptr;
 	mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-	uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
+	mz_uint64 mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+	mz_uint64 mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, mz_uint64 new_ofs);
 	size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
 	mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
 #endif

 /* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
 /* It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. */
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);

 /* Validates an entire archive by calling mz_zip_validate_file() on each file. */
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);

 /* Misc utils/helpers, valid for ZIP reading or writing */
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
+MINIZ_EXPORT mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
+#ifndef MINIZ_NO_STDIO
+MINIZ_EXPORT mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
+#endif

 /* Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end(). */
-mz_bool mz_zip_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_end(mz_zip_archive *pZip);

 /* -------- ZIP writing */

@@ -1245,16 +1326,16 @@ mz_bool mz_zip_end(mz_zip_archive *pZip);
 /* Inits a ZIP archive writer. */
 /*Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init or mz_zip_writer_init_v2*/
 /*The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n*/
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);

-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);

 #ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
 #endif

 /* Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive. */
@@ -1263,56 +1344,57 @@ mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint f
 /* Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL. */
 /* Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before */
 /* the archive is finalized the file's central directory will be hosed. */
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);

 /* Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive. */
 /* To add a directory entry, call this method with an archive name ending in a forwardslash with an empty buffer. */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);

 /* Like mz_zip_writer_add_mem(), except you can specify a file comment field, and optionally supply the function with already compressed data. */
 /* uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified. */
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
+                                              mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);

-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                    mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                    const char *user_extra_data_central, mz_uint user_extra_data_central_len);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
+                                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
+                                                 const char *user_extra_data_central, mz_uint user_extra_data_central_len);

 /* Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. */
 /* File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.*/
-mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 size_to_add,
+MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 max_size,
 	const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
 	const char *user_extra_data_central, mz_uint user_extra_data_central_len);

+
 #ifndef MINIZ_NO_STDIO
 /* Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive. */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);

 /* Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream. */
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add,
+MINIZ_EXPORT mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size,
                                const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
                                const char *user_extra_data_central, mz_uint user_extra_data_central_len);
 #endif

 /* Adds a file to an archive by fully cloning the data from another archive. */
 /* This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data. */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);

 /* Finalizes the archive by writing the central directory records followed by the end of central directory record. */
 /* After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end(). */
 /* An archive must be manually finalized by calling this function for it to be valid. */
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);

-/* Finalizes a heap archive, returning a poiner to the heap block and its size. */
+/* Finalizes a heap archive, returning a pointer to the heap block and its size. */
 /* The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks. */
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);
+MINIZ_EXPORT mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);

 /* Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used. */
 /* Note for the archive to be valid, it *must* have been finalized before ending (this function will not do it for you). */
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_writer_end(mz_zip_archive *pZip);

 /* -------- Misc. high-level helper functions: */

@@ -1320,14 +1402,16 @@ mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
 /* Note this is NOT a fully safe operation. If it crashes or dies in some way your archive can be left in a screwed up state (without a central directory). */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
 /* TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong. */
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);
+MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);

+#ifndef MINIZ_NO_STDIO
 /* Reads a single file from an archive into a heap block. */
 /* If pComment is not NULL, only the file with the specified comment will be extracted. */
 /* Returns NULL on failure. */
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
+MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
+#endif

 #endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */

--- a/Show More
+++ b/Show More