Update edit_config_template.html

CamFrameSize is no longer needed/used for zoom

.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.

.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

.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.

.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

.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
+  

.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 [Digital 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 [Digital 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/).

.github/workflows/build.yaml

@@ -0,0 +1,430 @@
+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
+      if: startsWith(github.ref, 'refs/tags/') 
+      uses: Simply007/get-version-action@v2
+
+#    # the changelog [unreleased] will now be changed to the release version
+#    - name: Update changelog
+#      uses: thomaseizinger/keep-a-changelog-new-release@v1
+#      if: startsWith(github.ref, 'refs/tags/') 
+#      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
+#      if: startsWith(github.ref, 'refs/tags/') 
+#      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@v1
+      # 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
+      if: startsWith(github.ref, 'refs/tags/')
+      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
+#      if: startsWith(github.ref, 'refs/tags/') 
+#      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:    
+    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!

.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")

.github/workflows/manual-update-webinstaller.yaml

@@ -0,0 +1,63 @@
+# 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   
+  

.github/workflows/reply-bot.yaml

@@ -0,0 +1,80 @@
+# 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@v3
+      
+      
+      ####################################################################
+      ## 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@v1
+        with:
+          github_token: "${{ secrets.GITHUB_TOKEN }}"
+          config_file: .github/label-commenter-config.yaml

.gitignore

@@ -4,8 +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
@@ -18,3 +23,5 @@ CTestTestfile.cmake
 _deps
 code/edgeAI.code-workspace
 .DS_Store
+tools/parameter-tooltip-generator/html
+tools/parameter-tooltip-generator/AI-on-the-edge-device-docs

.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

FeatureRequest.md

@@ -2,18 +2,82 @@
 
 **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!
    
    
 
 ____
 
-#### #29 Add favicon and use the hostname for the website
 
-* https://github.com/jomjol/AI-on-the-edge-device/issues/927
+#### #40 Trigger with cron like exact time slot
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2470
+
+
+
+#### #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
 
@@ -49,9 +113,9 @@ ____
 
   
 
-#### #22 Direct hint to the different neural network files in the other repositories
+#### ~~#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
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/644~~
 
   
 
@@ -66,6 +130,8 @@ ____
 * 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
@@ -106,13 +172,13 @@ ____
 
 
 
-#### #14 Backup and restore option for configuration
+#### ~~#14 Backup and restore option for configuration~~- implemented v11.3.1
 
-* https://github.com/jomjol/AI-on-the-edge-device/issues/459
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/459~~
 
-* Implement a zip file compression for store and restore
+* ~~Implement a zip file compression for store and restore~~
 
-* Update the html to handle it
+* ~~Update the html to handle it~~
 
   
 

README.md

@@ -1,114 +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 (Water Meter)
-  - https://www.thingiverse.com/thing:5028229 (Power Meter)
-  - https://www.thingiverse.com/thing:4571627 (ESP32-Cam housing only)
+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.
 
+<img src="images/esp32-cam.png" width="200px">
+
+## 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 prefered 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).
 
-
-------
-## Change log
-**General remark:** Besides the file `firmware.bin`, typically the content of `/html` will need to be updated!
-
-------
-
-##### 11.1.1 - Intermediate Digits (2022-08-22)
-
-- New and improved consistency check (especially with analog and digital counters mixed)
-- Bug Fix: digital counter algorithm
-
-##### 11.0.1 - Intermediate Digits (2022-08-18)
-
-- **NEW v11.0.1**: Bug Fix InfluxDB configuration (only update of html.zip necessary)
-
-- Implementation of new CNN types to detect intermediate values of digits with rolling numbers
-
-  - By default the old algo (0, 1, ..., 9, "N") is active (due to the limited types of digits trained so far)
-  - Activation can be done by selection a tflite file with the new trained model in the 'config.ini'
-  - **Details can be found in the [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Neural-Network-Types)** (different types, trained image types, naming convention)
-
-- Updated  neural network files (and adaption to new naming convention)
-
-- Published a tool to download and combine log files - **Thanks to **
-
-  - Files see ['/tools/logfile-tool'](tbd), How-to see [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Gasmeter-Log-Downloader)
-
-- Bug Fix: InfluxDB enabling in grahic configuration
-
-  
+## Build It Yourself
+See [Build Instructions](code/README.md).
 
 ## Tools
-
 * Logfile downloader and combiner (Thx to [reserve85](https://github.com/reserve85))
-  * Files see ['/tools/logfile-tool'](tbd), How-to see [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Gasmeter-Log-Downloader)
-
-
+  * 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 followed currently - mainly due to capacity reasons on side of the developer. They are collected here: [FeatureRequest.md](FeatureRequest.md)
-
-
-
-------
-
-## History
-
-##### 10.6.2 - Stability Increase (2022-07-24)
-
-##### 9.2.0 - External Illumination (2021-12-02)
-
-##### 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)
-
+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).

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

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"

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"

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)

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.

code/components/esp-nn/.gitignore

@@ -1,57 +0,0 @@
-.config
-*.o
-*.i
-*.s
-*.orig
-*.pyc
-
-# gtags
-GTAGS
-GRTAGS
-GPATH
-
-# emacs
-.dir-locals.el
-
-# emacs temp file suffixes
-*~
-.#*
-\#*#
-
-# eclipse setting
-.settings
-
-# MacOS directory files
-.DS_Store
-
-# Example project files
-examples/**/sdkconfig
-examples/**/sdkconfig.old
-examples/**/build
-
-# Test app files
-test_app/build
-test_app/sdkconfig
-test_app/sdkconfig.old
-
-# Doc build artifacts
-docs/_build/
-docs/doxygen-warning-log.txt
-docs/sphinx-warning-log.txt
-docs/sphinx-warning-log-sanitized.txt
-docs/xml/
-docs/xml_in/
-docs/man/
-docs/doxygen_sqlite3.db
-
-TEST_LOGS
-
-
-# gcov coverage reports
-*.gcda
-*.gcno
-coverage.info
-coverage_report/
-
-# VS Code Settings
-.vscode/

code/components/esp-nn/.gitlab-ci.yml

@@ -1,55 +0,0 @@
-stages:
-  - build
-
-variables:
-  BATCH_BUILD: "1"
-  V: "0"
-  MAKEFLAGS: "-j8 --no-keep-going"
-  IDF_PATH: "$CI_PROJECT_DIR/esp-idf"
-  LOG_PATH: "$CI_PROJECT_DIR"
-
-.set_git_config: &set_git_config
-  # Set git config
-  - git config user.email "test@espressif.com"
-  - git config user.name "Espressif"
-
-.add_ssh_key: &add_ssh_key
-  # Add gitlab ssh key
-  - mkdir -p ~/.ssh
-  - chmod 700 ~/.ssh
-  - echo -n $GITLAB_KEY > ~/.ssh/id_rsa_base64
-  - base64 --decode --ignore-garbage ~/.ssh/id_rsa_base64 > ~/.ssh/id_rsa
-  - chmod 600 ~/.ssh/id_rsa
-  - echo -e "Host gitlab.espressif.cn\n\tStrictHostKeyChecking no\n" >> ~/.ssh/config
-
-before_script:
-  # Add gitlab ssh key
-  - *add_ssh_key
-  # Set git config
-  - *set_git_config
-
-.build_esp32s3: &build_esp32s3
-  - idf.py set-target esp32s3 build
-
-.build_esp32: &build_esp32
-  - idf.py set-target esp32 build
-
-build_demo:
-  stage: build
-  image: $CI_DOCKER_REGISTRY/esp32-ci-env:esp-nn
-  tags:
-    - build
-  script:
-    # Clone IDF
-    - git clone --recursive --single-branch -b release/v4.4 --reference-if-able /local_references/gitlab/ https://gitlab-ci-token:${BOT_TOKEN}@gitlab.espressif.cn:6688/espressif/esp-idf.git
-    - cd esp-idf
-    - ./install.sh
-    - . ./export.sh
-    - cd ..
-    # Build examples now
-    - cd test_app
-    # Build esp32s3
-    - *build_esp32s3
-    # Build esp32
-    - *build_esp32
-    - cd -

code/components/esp-nn/CMakeLists.txt

@@ -1,48 +0,0 @@
-idf_build_get_property(idf_target IDF_TARGET)
-
-set(c_srcs
-    "src/activation_functions/esp_nn_relu_ansi.c"
-    "src/basic_math/esp_nn_add_ansi.c"
-    "src/basic_math/esp_nn_mul_ansi.c"
-    "src/convolution/esp_nn_conv_ansi.c"
-    "src/convolution/esp_nn_depthwise_conv_ansi.c"
-    "src/fully_connected/esp_nn_fully_connected_ansi.c"
-    "src/softmax/esp_nn_softmax_ansi.c"
-    "src/softmax/esp_nn_softmax_opt.c"
-    "src/pooling/esp_nn_avg_pool_ansi.c"
-    "src/pooling/esp_nn_max_pool_ansi.c")
-
-if(CONFIG_IDF_TARGET_ESP32S3)
-    set(s3_srcs
-        "src/common/esp_nn_common_functions_esp32s3.S"
-        "src/common/esp_nn_multiply_by_quantized_mult_esp32s3.S"
-        "src/common/esp_nn_multiply_by_quantized_mult_ver1_esp32s3.S"
-        "src/activation_functions/esp_nn_relu_s8_esp32s3.S"
-        "src/basic_math/esp_nn_add_s8_esp32s3.S"
-        "src/basic_math/esp_nn_mul_s8_esp32s3.S"
-        "src/convolution/esp_nn_conv_esp32s3.c"
-        "src/convolution/esp_nn_depthwise_conv_s8_esp32s3.c"
-        "src/convolution/esp_nn_conv_s16_mult8_esp32s3.S"
-        "src/convolution/esp_nn_conv_s16_mult8_1x1_esp32s3.S"
-        "src/convolution/esp_nn_conv_s16_mult4_1x1_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s8_mult1_3x3_padded_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult1_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult1_3x3_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult1_3x3_no_pad_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult8_3x3_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult4_esp32s3.S"
-        "src/convolution/esp_nn_depthwise_conv_s16_mult8_esp32s3.S"
-        "src/fully_connected/esp_nn_fully_connected_s8_esp32s3.S"
-        "src/pooling/esp_nn_max_pool_s8_esp32s3.S"
-        "src/pooling/esp_nn_avg_pool_s8_esp32s3.S")
-endif()
-
-idf_component_register(SRCS "${c_srcs}"
-                            "${s3_srcs}"
-                       INCLUDE_DIRS "include" "src/common")
-
-if(CONFIG_IDF_TARGET_ESP32S3)
-    target_compile_options(${COMPONENT_LIB} PRIVATE -mlongcalls -fno-unroll-loops -O2 -Wno-unused-function)
-else()
-    target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-unused-function)
-endif()

code/components/esp-nn/Kconfig.projbuild

@@ -1,29 +0,0 @@
-menu "ESP-NN"
-
-choice NN_OPTIMIZATIONS
-   bool "Optimization for nn functions"
-   default NN_OPTIMIZED
-   help
-      Use ANSI-C versions for verification and debug purpose.
-      Optimisations are automatically picked up for a chipset.
-      For ESP32-S3, assembly Optimisations are selected.
-      For ESP32, just the ANSI C versions are selected for now.
-
-config NN_ANSI_C
-   bool "ANSI C"
-   help
-      ANSI C versions for verification and debug purposes.
-config NN_OPTIMIZED
-   bool "Optimized versions"
-   help
-      Optimisations are automatically picked up for a chipset.
-      For ESP32-S3, assembly Optimisations are selected.
-      For ESP32, just the ANSI C versions are selected for now.
-endchoice
-
-config NN_OPTIMIZATIONS
-   int
-   default 0 if NN_ANSI_C
-   default 1 if NN_OPTIMIZED
-
-endmenu

code/components/esp-nn/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.

code/components/esp-nn/README.md

@@ -1,54 +0,0 @@
-# ESP-NN
-
-The library contains optimised NN (Neural Network) functions for various Espressif chipsets.
-
-* Supported platforms:
-   * TensorFlow Lite Micro (TFLite Micro). Repo can be found [here](https://github.com/espressif/tflite-micro-esp-examples)
-
-* Supported ESP chipsets include:
-   * ESP32-S3 (Assembly versions optimised to benefit from vector instructions of ESP32-S3)
-   * ESP32 (ANSI C versions)
-
-## Performance
-
-### Kernelwise performance for s8 versions:
-
-  * Kernelwise performance on ESP32-S3 chip
-    * Numbers are ticks taken for kernel to execute
-    * Chip config: 240MHz, SPI: QPI 80MHz, Data cache: 64KB
-
-    | Function        | ANSI C  | ESP32-S3 Opt  | Opt Ratio | Data info   | Memory    |
-    | ----------------| --------|---------|---------|-------------|-----------|
-    | elementwise_add | 320397  | 87119   | 3.68    | size = 1615 | External  |
-    | elementwise_mul | 125958  | 44239   | 2.85    | size = 1615 | External  |
-    | convolution     | 4663012 | 428675  | 10.88   | input(10,10), filter(64x1x1x64) | External |
-    | convolution     | 301014  | 32433   | 9.28    | input(8,8), filter(16x1x1x16) | External |
-    | convolution     | 2115418 | 1020923 | 2.07    | input(10,10), filter(64x3x3x3) | External |
-    | depthwise conv  | 1190062 | 203278  | 5.85    | input (18, 18), pad(0,0), stride(1,1) filter: 1x3x3x16 | External |
-    | depthwise conv  | 837072  | 182335  | 4.59    | input (12, 12), pad(1,1), stride(1,1)  filter: 8x5x5x4 | External |
-    | max pool        | 485714  | 76747   | 6.33    | input(16,16), filter (1x3x3x16) | Internal |
-    | avg pool        | 541462  | 160580  | 3.37    | input(16,16), filter (1x3x3x16) | Internal |
-    | fully connected | 15853   | 9547    | 1.66    | len: 265, ch = 3 | Internal |
-    | prelu (relu6)   | 19472   | 2734    | 7.12    | size, 1615  | Internal  |
-
-
-## Configuration
-
-  * To configure, please use `idf.py menuconfig` and under `ESP-NN` select `NN_OPTIMIZATIONS`
-  * There are two options presented:
-     * Optimized versions
-     * ANSI C
-
-  * Default selection is for `Optimized versions`. For ESP32-S3, assembly versions are automatically selected, whereas for ESP32,  ANSI-C versions are selected by default.
-  * For debugging purposes, you may want to select `ANSI C`
-
-
-## Contributing
-
-If you encounter an issue with ESP-NN, or wish to submit a feature request, please use the Issues section on the Github.
-
-For general questions related to this library, please use the esp32.com forum.
-
-## Copyrights and License
-
-All original source code in this repository is Copyright (C) 2020-2021 Espressif Systems. This source code is licensed under the Apache License 2.0 as described in the file LICENSE.

code/components/esp-nn/include/esp_nn.h

@@ -1,46 +0,0 @@
-// Copyright 2020-2021 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.
-
-#pragma once
-
-#if defined(CONFIG_NN_OPTIMIZED)
-#ifdef CONFIG_IDF_TARGET_ESP32S3
-#define ARCH_ESP32_S3 1
-#endif
-#ifdef CONFIG_IDF_TARGET_ESP32
-#define ARCH_ESP32 1
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* reference kernels included by default */
-#include "esp_nn_ansi_headers.h"
-
-#if defined(CONFIG_NN_OPTIMIZED)
-#ifdef ARCH_ESP32_S3
-#include "esp_nn_esp32s3.h"
-#endif
-#ifdef ARCH_ESP32
-#include "esp_nn_esp32.h"
-#endif
-#else
-#include "esp_nn_ansi_c.h"
-#endif
-
-#ifdef __cplusplus
-}
-#endif

code/components/esp-nn/include/esp_nn_ansi_c.h

@@ -1,46 +0,0 @@
-// Copyright 2020-2021 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.
-
-/**
- * @file        Header definitions to include for ANSI C versions.
- *              These are just typedefs to pick up ANSI versions.
- */
-
-#pragma once
-
-#include "esp_nn_ansi_headers.h"
-
-#define esp_nn_add_elementwise_s8 esp_nn_add_elementwise_s8_ansi
-#define esp_nn_mul_elementwise_s8 esp_nn_mul_elementwise_s8_ansi
-
-#define esp_nn_depthwise_conv_s8 esp_nn_depthwise_conv_s8_ansi
-
-#define esp_nn_conv_s8 esp_nn_conv_s8_ansi
-
-#define esp_nn_get_conv_scratch_size esp_nn_get_conv_scratch_size_ansi
-#define esp_nn_set_conv_scratch_buf esp_nn_set_conv_scratch_buf_ansi
-
-#define esp_nn_get_depthwise_conv_scratch_size esp_nn_get_depthwise_conv_scratch_size_ansi
-#define esp_nn_set_depthwise_conv_scratch_buf esp_nn_set_depthwise_conv_scratch_buf_ansi
-
-#define esp_nn_relu6_s8 esp_nn_relu6_s8_ansi
-
-#define esp_nn_avg_pool_s8 esp_nn_avg_pool_s8_ansi
-#define esp_nn_max_pool_s8 esp_nn_max_pool_s8_ansi
-
-#define esp_nn_fully_connected_s8 esp_nn_fully_connected_s8_ansi
-
-#define esp_nn_get_softmax_scratch_size esp_nn_get_softmax_scratch_size_ansi
-#define esp_nn_set_softmax_scratch_buf esp_nn_set_softmax_scratch_buf_ansi
-#define esp_nn_softmax_s8 esp_nn_softmax_s8_ansi

code/components/esp-nn/include/esp_nn_ansi_headers.h

@@ -1,283 +0,0 @@
-// Copyright 2020-2021 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.
-
-#pragma once
-
-/**
- * @file        Header definitions to include for esp_nn reference functions
- */
-
-#include <stdint.h>
-
-/************************** Basic math functions ****************************/
-
-/**
- * @brief       elementwise addition
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- *
- *              shift values are expected to be <= 0
- */
-void esp_nn_add_elementwise_s8_ansi(const int8_t *input1_data,
-                                    const int8_t *input2_data,
-                                    const int32_t input1_offset,
-                                    const int32_t input2_offset,
-                                    const int32_t input1_mult,
-                                    const int32_t input2_mult,
-                                    const int32_t input1_shift,
-                                    const int32_t input2_shift,
-                                    const int32_t left_shift,
-                                    int8_t *output,
-                                    const int32_t out_offset,
-                                    const int32_t out_mult,
-                                    const int32_t out_shift,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max,
-                                    const int32_t size);
-/**
- * @brief       elementwise multiplication
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- *
- *              output shift is expected to be <= 0
- */
-void esp_nn_mul_elementwise_s8_ansi(const int8_t *input1_data,
-                                    const int8_t *input2_data,
-                                    const int32_t input1_offset,
-                                    const int32_t input2_offset,
-                                    int8_t *output,
-                                    const int32_t out_offset,
-                                    const int32_t out_mult,
-                                    const int32_t out_shift,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max,
-                                    const int32_t size);
-
-
-/************************** Convolution functions *****************************/
-
-/**
- * @brief       depthwise convolution per channel
- *
- * @note        inputs type: int8_t, output: int8_t
- *              Version used in tflite is per channel.
- *              This version follows the same footsprints.
- *              Meaning, it has per out_channel shift and multiplier for
- *              requantization
- *
- *              optimization notes: Though input_offset is int32 type,
- *              offset values are contained in 8 bits [-128, 127]
- */
-void esp_nn_depthwise_conv_s8_ansi(const int8_t *input_data,
-                                   const uint16_t input_wd,
-                                   const uint16_t input_ht,
-                                   const uint16_t channels,
-                                   const int32_t input_offset,
-                                   const uint16_t pad_wd,
-                                   const uint16_t pad_ht,
-                                   const uint16_t stride_wd,
-                                   const uint16_t stride_ht,
-                                   const uint16_t ch_mult,
-                                   const int8_t *filter_data,
-                                   const uint16_t filter_wd,
-                                   const uint16_t filter_ht,
-                                   const int32_t *bias,
-                                   int8_t *out_data,
-                                   const uint16_t out_wd,
-                                   const uint16_t out_ht,
-                                   const int32_t out_offset,
-                                   const int32_t *out_shift,
-                                   const int32_t *out_mult,
-                                   const int32_t activation_min,
-                                   const int32_t activation_max);
-
-/**
- * @brief       2d-convolution channelwise
- *
- * @note        operation: result += (input + offset) * filter
- *
- *              inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_conv_s8_ansi(const int8_t *input_data,
-                         const uint16_t input_wd,
-                         const uint16_t input_ht,
-                         const uint16_t in_channels,
-                         const int32_t input_offset,
-                         const uint16_t pad_wd,
-                         const uint16_t pad_ht,
-                         const uint16_t stride_wd,
-                         const uint16_t stride_ht,
-                         const int8_t *filter_data,
-                         const uint16_t filter_wd,
-                         const uint16_t filter_ht,
-                         const int32_t *bias,
-                         int8_t *out_data,
-                         const uint16_t out_wd,
-                         const uint16_t out_ht,
-                         const uint16_t out_channels,
-                         const int32_t out_offset,
-                         const int32_t *out_shift,
-                         const int32_t *out_mult,
-                         const int32_t activation_min,
-                         const int32_t activation_max);
-
-int esp_nn_get_conv_scratch_size_ansi(const uint16_t input_wd,
-                                      const uint16_t input_ht,
-                                      const uint16_t in_ch,
-                                      const uint16_t out_ch,
-                                      const uint16_t filter_wd,
-                                      const uint16_t filter_ht);
-void esp_nn_set_conv_scratch_buf_ansi(const void *buf);
-
-int esp_nn_get_depthwise_conv_scratch_size_ansi(const uint16_t input_wd,
-                                                const uint16_t input_ht,
-                                                const uint16_t channels,
-                                                const uint16_t ch_mult,
-                                                const uint16_t filter_wd,
-                                                const uint16_t filter_ht);
-void esp_nn_set_depthwise_conv_scratch_buf_ansi(const void *buf);
-
-/************************** Activation functions *****************************/
-
-/**
- * @brief       relu6
- *
- * @note        inout: int8_t
- */
-void esp_nn_relu6_s8_ansi(int8_t *data, uint16_t size);
-
-/************************** Pooling functions *****************************/
-
-
-/**
- * @brief       max_pool
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_max_pool_s8_ansi(const int8_t *input,
-                             const uint16_t input_wd,
-                             const uint16_t input_ht,
-                             int8_t *output,
-                             const uint16_t output_wd,
-                             const uint16_t output_ht,
-                             const uint16_t stride_wd,
-                             const uint16_t stride_ht,
-                             const uint16_t filter_wd,
-                             const uint16_t filter_ht,
-                             const uint16_t pad_wd,
-                             const uint16_t pad_ht,
-                             const int32_t activation_min,
-                             const int32_t activation_max,
-                             const uint16_t channels);
-
-/**
- * @brief       avg_pool
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_avg_pool_s8_ansi(const int8_t *input,
-                             const uint16_t input_wd,
-                             const uint16_t input_ht,
-                             int8_t *output,
-                             const uint16_t output_wd,
-                             const uint16_t output_ht,
-                             const uint16_t stride_wd,
-                             const uint16_t stride_ht,
-                             const uint16_t filter_wd,
-                             const uint16_t filter_ht,
-                             const uint16_t pad_wd,
-                             const uint16_t pad_ht,
-                             const int32_t activation_min,
-                             const int32_t activation_max,
-                             const uint16_t channels);
-
-
-/************************** Fully connected functions ***********************/
-
-/**
- * @brief       fully connected
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_fully_connected_s8_ansi(const int8_t *input_data,
-                                    const int32_t input_offset,
-                                    const uint16_t row_len,
-                                    const int8_t *filter_data,
-                                    const int32_t filter_offset,
-                                    const int32_t *bias,
-                                    int8_t *out_data,
-                                    const uint16_t out_channels,
-                                    const int32_t out_offset,
-                                    const int32_t out_shift,
-                                    const int32_t out_mult,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max);
-
-/**
- * @brief   Get scratch buffer size needed by softmax function
- *
- * @param   width
- * @param   height
- * @return  size in bytes
- *
- * @note    buffer must be 4 byte aligned
- */
-int32_t esp_nn_get_softmax_scratch_size_ansi(const int32_t width, const int32_t height);
-
-/* ANSI C function to be hooked up when optimised version needed */
-int32_t esp_nn_get_softmax_scratch_size_opt(const int32_t width, const int32_t height);
-
-/**
- * @brief   Set scratch buffer to be used by softmax function
- *
- * @param   buffer  this can be NULL if one needs to unset it
- *                  must be aligned to 4 bytes
- */
-void esp_nn_set_softmax_scratch_buf_ansi(void *buffer);
-
-/* ANSI C function to be hooked up when optimised version needed */
-void esp_nn_set_softmax_scratch_buf_opt(void *buffer);
-
-/**
- * @brief       reference softmax function
- *
- * @note        inputs type: int8_t, output: int8_t
- */
-void esp_nn_softmax_s8_ansi(const int8_t *input_data,
-                            const int32_t height,
-                            const int32_t width,
-                            const int32_t mult,
-                            const int32_t shift,
-                            const int32_t diff_min,
-                            int8_t *output_data);
-
-/**
- * @brief       optimised version of softmax function
- *
- * @note        the function uses extra buffer (4 * width bytes)
- *              hence, scratch buffers must be set before calling this.
- */
-void esp_nn_softmax_s8_opt(const int8_t *input_data,
-                           const int32_t height,
-                           const int32_t width,
-                           const int32_t mult,
-                           const int32_t shift,
-                           const int32_t diff_min,
-                           int8_t *output_data);

code/components/esp-nn/include/esp_nn_esp32.h

@@ -1,48 +0,0 @@
-// Copyright 2020-2021 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.
-
-/**
- * @file        Header definitions to include for esp_nn optimized functions for
- *              the ESP32 platform.
- *              We are hooking up just the C versions for now.
- *              The file hence is exactly same as `esp_nn_ansi_c.h`
- */
-
-#pragma once
-
-#include "esp_nn_ansi_headers.h"
-
-#define esp_nn_add_elementwise_s8 esp_nn_add_elementwise_s8_ansi
-#define esp_nn_mul_elementwise_s8 esp_nn_mul_elementwise_s8_ansi
-
-#define esp_nn_depthwise_conv_s8 esp_nn_depthwise_conv_s8_ansi
-
-#define esp_nn_conv_s8 esp_nn_conv_s8_ansi
-
-#define esp_nn_get_conv_scratch_size esp_nn_get_conv_scratch_size_ansi
-#define esp_nn_set_conv_scratch_buf esp_nn_set_conv_scratch_buf_ansi
-
-#define esp_nn_get_depthwise_conv_scratch_size esp_nn_get_depthwise_conv_scratch_size_ansi
-#define esp_nn_set_depthwise_conv_scratch_buf esp_nn_set_depthwise_conv_scratch_buf_ansi
-
-#define esp_nn_relu6_s8 esp_nn_relu6_s8_ansi
-
-#define esp_nn_avg_pool_s8 esp_nn_avg_pool_s8_ansi
-#define esp_nn_max_pool_s8 esp_nn_max_pool_s8_ansi
-
-#define esp_nn_fully_connected_s8 esp_nn_fully_connected_s8_ansi
-
-#define esp_nn_get_softmax_scratch_size esp_nn_get_softmax_scratch_size_opt
-#define esp_nn_set_softmax_scratch_buf esp_nn_set_softmax_scratch_buf_opt
-#define esp_nn_softmax_s8 esp_nn_softmax_s8_opt

code/components/esp-nn/include/esp_nn_esp32s3.h

@@ -1,261 +0,0 @@
-// Copyright 2020-2021 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.
-
-/**
- * @file        Header definitions to include for esp_nn optimized functions for
- *              the ESP32-S3 platform
- */
-
-#pragma once
-
-#include <stdint.h>
-#include "esp_nn_ansi_headers.h"
-
-/************************** Basic math functions *****************************/
-
-
-/**
- * @brief       elementwise addition
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- *
- *              shift values are expected to be <= 0
- */
-void esp_nn_add_elementwise_s8_esp32s3(const int8_t *input1_data,
-                                       const int8_t *input2_data,
-                                       const int32_t input1_offset,
-                                       const int32_t input2_offset,
-                                       const int32_t input1_mult,
-                                       const int32_t input2_mult,
-                                       const int32_t input1_shift,
-                                       const int32_t input2_shift,
-                                       const int32_t left_shift,
-                                       int8_t *output,
-                                       const int32_t out_offset,
-                                       const int32_t out_mult,
-                                       const int32_t out_shift,
-                                       const int32_t activation_min,
-                                       const int32_t activation_max,
-                                       const int32_t size);
-
-/**
- * @brief       elementwise multiplication
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- *
- *              output shift is expected to be <= 0
- */
-void esp_nn_mul_elementwise_s8_esp32s3(const int8_t *input1_data,
-                                       const int8_t *input2_data,
-                                       const int32_t input1_offset,
-                                       const int32_t input2_offset,
-                                       int8_t *output,
-                                       const int32_t out_offset,
-                                       const int32_t out_mult,
-                                       const int32_t out_shift,
-                                       const int32_t activation_min,
-                                       const int32_t activation_max,
-                                       const int32_t size);
-
-
-/************************** Convolution functions *****************************/
-
-/**
- * @brief       depthwise convolution per channel
- *
- * @note        inputs type: int8_t, output: int8_t
- *              Version used in tflite is per channel.
- *              This version follows the same footsprints.
- *              Meaning, it has per out_channel shift and multiplier for
- *              requantization
- *
- *              optimization notes: Though input_offset is int32 type,
- *              offset values are contained in 8 bits [-128, 127]
- */
-void esp_nn_depthwise_conv_s8_esp32s3(const int8_t *input_data,
-                                      const uint16_t input_wd,
-                                      const uint16_t input_ht,
-                                      const uint16_t channels,
-                                      const int32_t input_offset,
-                                      const uint16_t pad_wd,
-                                      const uint16_t pad_ht,
-                                      const uint16_t stride_wd,
-                                      const uint16_t stride_ht,
-                                      const uint16_t ch_mult,
-                                      const int8_t *filter_data,
-                                      const uint16_t filter_wd,
-                                      const uint16_t filter_ht,
-                                      const int32_t *bias,
-                                      int8_t *out_data,
-                                      const uint16_t out_wd,
-                                      const uint16_t out_ht,
-                                      const int32_t out_offset,
-                                      const int32_t *out_shift,
-                                      const int32_t *out_mult,
-                                      const int32_t activation_min,
-                                      const int32_t activation_max);
-
-/**
- * @brief       2d - convolution channelwise
- *
- * @note        operation: result += (input + offset) * filter
- *
- *              inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_conv_s8_esp32s3(const int8_t *input_data,
-                            const uint16_t input_wd,
-                            const uint16_t input_ht,
-                            const uint16_t in_channels,
-                            const int32_t input_offset,
-                            const uint16_t pad_wd,
-                            const uint16_t pad_ht,
-                            const uint16_t stride_wd,
-                            const uint16_t stride_ht,
-                            const int8_t *filter_data,
-                            const uint16_t filter_wd,
-                            const uint16_t filter_ht,
-                            const int32_t *bias,
-                            int8_t *out_data,
-                            const uint16_t out_wd,
-                            const uint16_t out_ht,
-                            const uint16_t out_channels,
-                            const int32_t out_offset,
-                            const int32_t *out_shift,
-                            const int32_t *out_mult,
-                            const int32_t activation_min,
-                            const int32_t activation_max);
-
-int esp_nn_get_conv_scratch_size_esp32s3(const uint16_t input_wd,
-                                         const uint16_t input_ht,
-                                         const uint16_t in_ch,
-                                         const uint16_t out_ch,
-                                         const uint16_t filter_wd,
-                                         const uint16_t filter_ht);
-void esp_nn_set_conv_scratch_buf_esp32s3(const void *buf);
-
-int esp_nn_get_depthwise_conv_scratch_size_esp32s3(const uint16_t input_wd,
-                                                   const uint16_t input_ht,
-                                                   const uint16_t channels,
-                                                   const uint16_t ch_mult,
-                                                   const uint16_t filter_wd,
-                                                   const uint16_t filter_ht);
-void esp_nn_set_depthwise_conv_scratch_buf_esp32s3(const void *buf);
-
-/************************** Pooling functions *****************************/
-
-/**
- * @brief       max_pool
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_max_pool_s8_esp32s3(const int8_t *input,
-                                const uint16_t input_wd,
-                                const uint16_t input_ht,
-                                int8_t *output,
-                                const uint16_t output_wd,
-                                const uint16_t output_ht,
-                                const uint16_t stride_wd,
-                                const uint16_t stride_ht,
-                                const uint16_t filter_wd,
-                                const uint16_t filter_ht,
-                                const uint16_t pad_wd,
-                                const uint16_t pad_ht,
-                                const int32_t activation_min,
-                                const int32_t activation_max,
-                                const uint16_t channels);
-
-/**
- * @brief       avg_pool
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- */
-void esp_nn_avg_pool_s8_esp32s3(const int8_t *input,
-                                const uint16_t input_wd,
-                                const uint16_t input_ht,
-                                int8_t *output,
-                                const uint16_t output_wd,
-                                const uint16_t output_ht,
-                                const uint16_t stride_wd,
-                                const uint16_t stride_ht,
-                                const uint16_t filter_wd,
-                                const uint16_t filter_ht,
-                                const uint16_t pad_wd,
-                                const uint16_t pad_ht,
-                                const int32_t activation_min,
-                                const int32_t activation_max,
-                                const uint16_t channels);
-
-
-/************************** Fully connected functions *****************************/
-
-/**
- * @brief       fully connected
- *
- * @note        inputs type: int8_t, output: int8_t
- *              input offsets: although int32_t, they are contained in 8 bits [-128, 127]
- *
- *              Current version works only on aligned input.
- *              row_len and channels should both be multiple of 8.
- */
-void esp_nn_fully_connected_s8_esp32s3(const int8_t *input_data,
-                                       const int32_t input_offset,
-                                       const uint16_t row_len,
-                                       const int8_t *filter_data,
-                                       const int32_t filter_offset,
-                                       const int32_t *bias,
-                                       int8_t *out_data,
-                                       const uint16_t out_channels,
-                                       const int32_t out_offset,
-                                       const int32_t out_shift,
-                                       const int32_t out_mult,
-                                       const int32_t activation_min,
-                                       const int32_t activation_max);
-
-/**
- * @brief       relu6
- *
- * @note        inout: int8_t
- */
-void esp_nn_relu6_s8_esp32s3(int8_t *data, uint16_t size);
-
-/********************** function defines ***************************/
-
-#define esp_nn_add_elementwise_s8 esp_nn_add_elementwise_s8_esp32s3
-#define esp_nn_mul_elementwise_s8 esp_nn_mul_elementwise_s8_esp32s3
-
-#define esp_nn_depthwise_conv_s8 esp_nn_depthwise_conv_s8_esp32s3
-
-#define esp_nn_get_conv_scratch_size esp_nn_get_conv_scratch_size_esp32s3
-#define esp_nn_set_conv_scratch_buf esp_nn_set_conv_scratch_buf_esp32s3
-
-#define esp_nn_get_depthwise_conv_scratch_size esp_nn_get_depthwise_conv_scratch_size_esp32s3
-#define esp_nn_set_depthwise_conv_scratch_buf esp_nn_set_depthwise_conv_scratch_buf_esp32s3
-
-#define esp_nn_conv_s8 esp_nn_conv_s8_esp32s3
-
-#define esp_nn_relu6_s8 esp_nn_relu6_s8_esp32s3
-
-#define esp_nn_avg_pool_s8 esp_nn_avg_pool_s8_esp32s3
-#define esp_nn_max_pool_s8 esp_nn_max_pool_s8_esp32s3
-
-#define esp_nn_fully_connected_s8 esp_nn_fully_connected_s8_esp32s3
-
-#define esp_nn_get_softmax_scratch_size esp_nn_get_softmax_scratch_size_opt
-#define esp_nn_set_softmax_scratch_buf esp_nn_set_softmax_scratch_buf_opt
-#define esp_nn_softmax_s8 esp_nn_softmax_s8_opt

code/components/esp-nn/src/activation_functions/esp_nn_relu_ansi.c

@@ -1,30 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdlib.h>
-
-#include <common_functions.h>
-
-void esp_nn_relu6_s8_ansi(int8_t *data, uint16_t size)
-{
-    int32_t i;
-
-    for (i = 0; i < size; i++) {
-        int32_t ip = data[i];
-
-        ip = max(ip, 0);
-        data[i] = min(ip, 6);
-    }
-}

code/components/esp-nn/src/basic_math/esp_nn_add_ansi.c

@@ -1,97 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-void esp_nn_add_elementwise_u8_ansi(const uint8_t *input1_data,
-                                    const uint8_t *input2_data,
-                                    const int32_t input1_offset,
-                                    const int32_t input2_offset,
-                                    const int32_t input1_mult,
-                                    const int32_t input2_mult,
-                                    const int32_t input1_shift,
-                                    const int32_t input2_shift,
-                                    const int32_t left_shift,
-                                    uint8_t *output,
-                                    const int32_t out_offset,
-                                    const int32_t out_mult,
-                                    const int32_t out_shift,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max,
-                                    const int32_t size)
-{
-    for (int i = 0; i < size; i++) {
-        int32_t tmp1 = input1_data[i] + input1_offset;
-        int32_t tmp2 = input2_data[i] + input2_offset;
-
-        tmp1 <<= left_shift;
-        tmp2 <<= left_shift;
-
-        tmp1 = esp_nn_sat_round_doubling_high_mul(tmp1, input1_mult);
-        tmp2 = esp_nn_sat_round_doubling_high_mul(tmp2, input2_mult);
-
-        tmp1 = esp_nn_div_by_power_of_two(tmp1, -input1_shift);
-        tmp2 = esp_nn_div_by_power_of_two(tmp2, -input2_shift);
-
-        int32_t out = tmp1 + tmp2;
-        out = esp_nn_sat_round_doubling_high_mul(out, out_mult);
-        out = esp_nn_div_by_power_of_two(out, -out_shift);
-        out = out + out_offset;
-
-        out = max(activation_min, min(out, activation_max));
-        output[i] = (uint8_t) out;
-    }
-}
-
-void esp_nn_add_elementwise_s8_ansi(const int8_t *input1_data,
-                                    const int8_t *input2_data,
-                                    const int32_t input1_offset,
-                                    const int32_t input2_offset,
-                                    const int32_t input1_mult,
-                                    const int32_t input2_mult,
-                                    const int32_t input1_shift,
-                                    const int32_t input2_shift,
-                                    const int32_t left_shift,
-                                    int8_t *output,
-                                    const int32_t out_offset,
-                                    const int32_t out_mult,
-                                    const int32_t out_shift,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max,
-                                    const int32_t size)
-{
-    for (int i = 0; i < size; i++) {
-        int32_t tmp1 = input1_data[i] + input1_offset;
-        int32_t tmp2 = input2_data[i] + input2_offset;
-
-        tmp1 <<= left_shift;
-        tmp2 <<= left_shift;
-
-        tmp1 = esp_nn_sat_round_doubling_high_mul(tmp1, input1_mult);
-        tmp2 = esp_nn_sat_round_doubling_high_mul(tmp2, input2_mult);
-
-        tmp1 = esp_nn_div_by_power_of_two(tmp1, -input1_shift);
-        tmp2 = esp_nn_div_by_power_of_two(tmp2, -input2_shift);
-
-        int32_t out = tmp1 + tmp2;
-        out = esp_nn_sat_round_doubling_high_mul(out, out_mult);
-        out = esp_nn_div_by_power_of_two(out, -out_shift);
-        out = out + out_offset;
-
-        out = max(activation_min, min(out, activation_max));
-        output[i] = (int8_t) out;
-    }
-}

code/components/esp-nn/src/basic_math/esp_nn_mul_ansi.c

@@ -1,42 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-void esp_nn_mul_elementwise_s8_ansi(const int8_t *input1_data,
-                                    const int8_t *input2_data,
-                                    const int32_t input1_offset,
-                                    const int32_t input2_offset,
-                                    int8_t *output,
-                                    const int32_t out_offset,
-                                    const int32_t out_mult,
-                                    const int32_t out_shift,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max,
-                                    const int32_t size)
-{
-    for (int i = 0; i < size; i++) {
-        int32_t tmp1 = input1_data[i] + input1_offset;
-        int32_t tmp2 = input2_data[i] + input2_offset;
-
-        int32_t out = tmp1 * tmp2;
-        out = esp_nn_multiply_by_quantized_mult(out, out_mult, out_shift);
-        out = out + out_offset;
-
-        out = max(activation_min, min(out, activation_max));
-        output[i] = (int8_t) out;
-    }
-}

code/components/esp-nn/src/common/common_functions.h

@@ -1,218 +0,0 @@
-// Copyright 2020-2021 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.
-
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-
-/**
- * c99 standard still doesn't strictly inline functions
- * We need to use attribute as well to do this.
- */
-#define __NN_FORCE_INLINE__ __attribute((always_inline)) static inline
-
-/* min/max macros */
-#ifndef max
-#define max(a, b) ({            \
-    __typeof__ (a) _a = (a);    \
-    __typeof__ (b) _b = (b);    \
-    _a > _b ? _a : _b;          \
-})
-
-#define min(a, b) ({            \
-    __typeof__ (a) _a = (a);    \
-    __typeof__ (b) _b = (b);    \
-    _a < _b ? _a : _b;          \
-})
-#endif
-
-__NN_FORCE_INLINE__ int32_t esp_nn_clz32(uint32_t in)
-{
-    __asm__ volatile("nsau %0, %0" : "+r" (in));
-    return in;
-}
-
-__NN_FORCE_INLINE__ int32_t esp_nn_pick_sat_high32_of64(int64_t val64)
-{
-    int32_t sign = (int32_t) (val64 >> 63);
-    int32_t to_add = sign & ((1ul << 31) - 1);
-    return (int32_t) ((int64_t) (val64 + to_add) >> 31);
-}
-
-/**
- * Signed saturate a 32 bit value to 8 bits keeping output in 32 bit variable.
- */
-__NN_FORCE_INLINE__ int32_t esp_nn_saturate8(int32_t in)
-{
-    __asm__ volatile("clamps %0, %0, 7" : "+a"(in));
-    return in;
-}
-
-__NN_FORCE_INLINE__ int32_t esp_nn_sat_round_doubling_high_mul(int32_t in0, int32_t in1)
-{
-    int32_t result;
-    int64_t in0_64 = (int64_t) in0;
-    bool overflow = (in0 == in1) && (in0 == (int32_t) INT32_MIN);
-
-    /* Nudge value */
-    int64_t nudge_val = 1 << 30;
-    if ((in0 < 0) ^ (in1 < 0)) {
-        nudge_val = 1 - nudge_val;
-    }
-
-    /* Multiply and add nudge */
-    int64_t mult = in0_64 * in1 + nudge_val;
-
-    /* Round and pickup 32 bits */
-    result = esp_nn_pick_sat_high32_of64(mult);
-
-    return overflow ? INT32_MAX : result;
-}
-
-/**
- * fast version
- * this will fail for values closer to INT32_MAX and INT32_MIN by `1 << (exponent - 1)`.
- * We can afford to do this because we are at the very last stage of filter.
- * Also it is pretty rare condition as our output is going to be 8 bit.
- */
-__NN_FORCE_INLINE__ int32_t esp_nn_div_by_power_of_two_fast(int32_t val, int32_t exponent)
-{
-    int32_t to_add = (1 << (exponent - 1)) - (val < 0);
-    return (int32_t) ((val + to_add) >> exponent);
-}
-
-__NN_FORCE_INLINE__ int32_t esp_nn_div_by_power_of_two(int32_t val, int32_t exponent)
-{
-    int32_t result;
-
-    const int32_t mask = (1 << exponent) - 1;
-    const int32_t remainder = val & mask;
-
-    result = val >> exponent;
-    int32_t threshold = (mask >> 1) + (result < 0);
-
-    if (remainder > threshold) {
-        result += 1;
-    }
-    return result;
-}
-
-__NN_FORCE_INLINE__ int32_t esp_nn_multiply_by_quantized_mult(int32_t x, int32_t mult, int32_t shift)
-{
-    int32_t left_shift = shift > 0 ? shift : 0;
-    int32_t right_shift = shift > 0 ? 0 : -shift;
-    int32_t result = esp_nn_sat_round_doubling_high_mul(x * (1 << left_shift), mult);
-    return esp_nn_div_by_power_of_two(result, right_shift);
-}
-
-__NN_FORCE_INLINE__ int32_t esp_nn_multiply_by_quantized_mult_fast(int32_t x, int32_t mult, int32_t shift)
-{
-    int32_t left_shift = max(shift, 0);
-    int32_t right_shift = left_shift - shift;
-
-    int64_t nudge_val = 1 << 30;
-    int64_t in0_64 = (int64_t) (x << left_shift);
-
-    /* Multiply and add nudge */
-    int64_t mult_64 = in0_64 * mult + nudge_val;
-    int32_t result = (int32_t) (mult_64 >> 31);
-    if (right_shift) {
-        result = esp_nn_div_by_power_of_two_fast(result, right_shift);
-    }
-    return result;
-}
-
-static void esp_nn_aligned_s8_pad_with_value(const int8_t *src, int8_t *dst,
-                                             const uint16_t input_wd,
-                                             const uint16_t input_ht,
-                                             const uint16_t channels,
-                                             const int32_t pad_val,
-                                             const uint16_t pad_wd,
-                                             const uint16_t pad_ht)
-{
-    /* memset with pad_val */
-    memset(dst, pad_val, ((input_wd + 2 * pad_wd) * (input_ht + 2 * pad_ht)) * channels * 2);
-    dst += (pad_wd + input_wd + pad_wd) * channels;
-
-    for (int i = 0; i < input_ht; i++) {
-        dst += pad_wd * channels;
-        for (int j = 0; j < input_wd * channels; j++) {
-            *dst++ = *src++;
-        }
-        dst += pad_wd * channels;
-    }
-}
-
-#if 0
-static void esp_nn_aligned_s8_pad_end_with_value(const int8_t *src, int8_t *dst,
-                                                 const uint16_t input_wd,
-                                                 const uint16_t input_ht,
-                                                 const uint16_t channels,
-                                                 const int32_t pad_val,
-                                                 const uint16_t pad_wd,
-                                                 const uint16_t pad_ht)
-{
-    for (int i = 0; i < input_ht; i++) {
-        for (int j = 0; j < input_wd * channels; j++) {
-            *dst++ = *src++;
-        }
-        memset(dst, pad_val, pad_wd * channels);
-        dst += pad_wd * channels;
-    }
-    /* pad end `pad_ht` lines at end */
-    memset(dst, pad_val, (input_wd + pad_wd) * pad_ht * channels);
-}
-#endif
-
-/**
- * @brief       convert 8 bit input data to 16 bit
- *
- * @param       src int8_t source data
- * @param       dst int16_t dst data
- * @param       size length of data
- * @param       offset  offset to be added to src data. Range: [-128, 127]
- */
-__NN_FORCE_INLINE__ void esp_nn_s8_to_s16_with_offset(const int8_t *src, int16_t *dst,
-                                                      const int size, const int32_t offset)
-{
-    int i = 0;
-    for (; i < size; i += 2) {
-        dst[i + 0] = src[i + 0] + offset;
-        dst[i + 1] = src[i + 1] + offset;
-    }
-    if(i < size) {
-        dst[i] = src[i] + offset;
-    }
-}
-
-/**
- * @brief       convert 8 bit input data to 16 bit
- *
- * @param       src int8_t source data
- * @param       dst int16_t dst data
- * @param       size length of data
- */
-__NN_FORCE_INLINE__ void esp_nn_s8_to_s16(const int8_t *src, int16_t *dst, const int size)
-{
-    int i = 0;
-    for (; i < size; i += 2) {
-        dst[i + 0] = src[i + 0];
-        dst[i + 1] = src[i + 1];
-    }
-    if(i < size) {
-        dst[i] = src[i];
-    }
-}

code/components/esp-nn/src/convolution/esp_nn_conv_ansi.c

@@ -1,175 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-int esp_nn_get_conv_scratch_size_ansi(const uint16_t input_wd,
-                                      const uint16_t input_ht,
-                                      const uint16_t in_ch,
-                                      const uint16_t out_ch,
-                                      const uint16_t filter_wd,
-                                      const uint16_t filter_ht)
-{
-    return 0;
-}
-
-void esp_nn_set_conv_scratch_buf_ansi(const void *buf)
-{
-
-}
-
-/**
- * Assumption 1: i/p channels == o/p channels
- * Assumption 2: Pointers are valid
- * Assumption 3: dialation width = 1
- */
-void esp_nn_conv_u8_ansi(const uint8_t *input_data,
-                         const uint16_t input_wd,
-                         const uint16_t input_ht,
-                         const uint16_t in_channels,
-                         const int32_t input_offset,
-                         const uint16_t pad_wd,
-                         const uint16_t pad_ht,
-                         const uint16_t stride_wd,
-                         const uint16_t stride_ht,
-                         const uint8_t *filter_data,
-                         const uint16_t filter_wd,
-                         const uint16_t filter_ht,
-                         const int32_t filter_offset,
-                         const int32_t *bias,
-                         uint8_t *out_data,
-                         const uint16_t out_wd,
-                         const uint16_t out_ht,
-                         const uint16_t out_channels,
-                         const int32_t out_offset,
-                         const int32_t out_shift,
-                         const int32_t out_mult,
-                         const int32_t activation_min,
-                         const int32_t activation_max)
-{
-    for (int out_y = 0; out_y < out_ht; out_y++) { //height loop
-        const int16_t base_y = (out_y * stride_ht) - pad_ht;
-        for (int out_x = 0; out_x < out_wd; out_x++) { //width_loop
-            const int16_t base_x = (out_x * stride_wd) - pad_wd;
-            for (int out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {//channel_loop
-                int32_t result = 0;
-
-                /* Select filter so as the point doesn't lie outside block */
-                int filter_y_start = max(0, -base_y);
-                int filter_x_start = max(0, -base_x);
-                int filter_y_end = min(filter_ht, input_ht - base_y);
-                int filter_x_end = min(filter_wd, input_wd - base_x);
-
-                for (int filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                    const int32_t idx_y = base_y + filter_y_idx;
-                    for (int filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                        const int32_t idx_x = base_x + filter_x_idx;
-                        for (int in_ch_idx = 0; in_ch_idx < in_channels; in_ch_idx++) {
-                            int32_t input_index = (idx_y * input_wd + idx_x) * in_channels + in_ch_idx;
-                            int32_t filter_index = ((out_ch_idx * filter_ht + filter_y_idx)
-                                                    * filter_wd + filter_x_idx) * in_channels
-                                                   + in_ch_idx;
-                            int32_t input_val = input_data[input_index] + input_offset;
-                            int32_t filter_val = filter_data[filter_index] + filter_offset;
-                            result += input_val * filter_val;
-                        }
-                    }
-                }
-                if (bias) {
-                    result += bias[out_ch_idx];
-                }
-                result = esp_nn_multiply_by_quantized_mult(result, out_mult, out_shift);
-                result += out_offset;
-                result = max(result, activation_min);
-                result = min(result, activation_max);
-
-                int out_index = (out_y * out_wd + out_x) * out_channels + out_ch_idx;
-                out_data[out_index] = (uint8_t) result;
-            }
-        }
-    }
-}
-
-/**
- * Assumption 1: i/p channels == o/p channels
- * Assumption 2: Pointers are valid
- * Assumption 3: dialation width = 1
- */
-void esp_nn_conv_s8_ansi(const int8_t *input_data,
-                         const uint16_t input_wd,
-                         const uint16_t input_ht,
-                         const uint16_t in_channels,
-                         const int32_t input_offset,
-                         const uint16_t pad_wd,
-                         const uint16_t pad_ht,
-                         const uint16_t stride_wd,
-                         const uint16_t stride_ht,
-                         const int8_t *filter_data,
-                         const uint16_t filter_wd,
-                         const uint16_t filter_ht,
-                         const int32_t *bias,
-                         int8_t *out_data,
-                         const uint16_t out_wd,
-                         const uint16_t out_ht,
-                         const uint16_t out_channels,
-                         const int32_t out_offset,
-                         const int32_t *out_shift,
-                         const int32_t *out_mult,
-                         const int32_t activation_min,
-                         const int32_t activation_max)
-{
-    int32_t out_ch_idx, out_y, out_x, in_ch_idx, filter_y_idx, filter_x_idx;
-
-    for (out_y = 0; out_y < out_ht; out_y++) {
-        for (out_x = 0; out_x < out_wd; out_x++) {
-            for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-                int32_t conv_out = 0;
-
-                const int32_t base_y = stride_ht * out_y - pad_ht;
-                const int32_t base_x = stride_wd * out_x - pad_wd;
-
-                const int32_t filter_y_start = max(0, -base_y);
-                const int32_t filter_x_start = max(0, -base_x);
-
-                const int32_t filter_y_end = min(filter_ht, input_ht - base_y);
-                const int32_t filter_x_end = min(filter_wd, input_wd - base_x);
-
-                for (filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                    for (filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                        const int32_t in_row = base_y + filter_y_idx;
-                        const int32_t in_col = base_x + filter_x_idx;
-                        int32_t input_base_offset = (in_row * input_wd + in_col) * in_channels;
-                        int32_t filter_base_offset = out_ch_idx * in_channels * filter_ht * filter_wd +
-                                                       (filter_y_idx * filter_wd + filter_x_idx) * in_channels;
-                        for (in_ch_idx = 0; in_ch_idx < in_channels; in_ch_idx++) {
-                            conv_out +=
-                                (input_data[input_base_offset + in_ch_idx] + input_offset) *
-                                filter_data[filter_base_offset + in_ch_idx];
-                        }
-                    }
-                }
-                if (bias) {
-                    conv_out += bias[out_ch_idx];
-                }
-                conv_out = esp_nn_multiply_by_quantized_mult(conv_out, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                conv_out += out_offset;
-                conv_out = max(conv_out, activation_min);
-                conv_out = min(conv_out, activation_max);
-                *out_data++ = (int8_t) conv_out;
-            }
-        }
-    }
-}

code/components/esp-nn/src/convolution/esp_nn_conv_esp32s3.c

@@ -1,436 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdio.h>
-
-#include <common_functions.h>
-
-static int16_t *scratch_buffer = NULL;
-
-extern void esp_nn_conv_s16_mult8_1x1_esp32s3(const int8_t *input_data,
-                                              const uint16_t input_wd,
-                                              const uint16_t input_ht,
-                                              const uint16_t in_channels,
-                                              const int32_t input_offset,
-                                              const int16_t *filter_data,
-                                              const int32_t *bias,
-                                              int8_t *out_data,
-                                              const uint16_t out_wd,
-                                              const uint16_t out_ht,
-                                              const uint16_t out_channels,
-                                              const int32_t out_offset,
-                                              const int32_t *out_shift,
-                                              const int32_t *out_mult,
-                                              const int32_t activation_min,
-                                              const int32_t activation_max,
-                                              void *buffer /* scratch buffer */);
-
-extern void esp_nn_conv_s16_mult4_1x1_esp32s3(const int16_t *input_data,
-                                              const uint16_t input_wd,
-                                              const uint16_t input_ht,
-                                              const uint16_t in_channels,
-                                              const int16_t *filter_data,
-                                              const int32_t *bias,
-                                              int8_t *out_data,
-                                              const uint16_t out_wd,
-                                              const uint16_t out_ht,
-                                              const uint16_t out_channels,
-                                              const int32_t out_offset,
-                                              const int32_t *out_shift,
-                                              const int32_t *out_mult,
-                                              const int32_t activation_min,
-                                              const int32_t activation_max,
-                                              void *buffer /* scratch buffer */);
-
-extern void esp_nn_conv_s16_mult8_esp32s3(const int16_t *input_data,
-                                          const uint16_t input_wd,
-                                          const uint16_t input_ht,
-                                          const uint16_t in_channels,
-                                          const uint16_t pad_wd,
-                                          const uint16_t pad_ht,
-                                          const uint16_t stride_wd,
-                                          const uint16_t stride_ht,
-                                          const int16_t *filter_data,
-                                          const uint16_t filter_wd,
-                                          const uint16_t filter_ht,
-                                          const int32_t *bias,
-                                          int8_t *out_data,
-                                          const uint16_t out_wd,
-                                          const uint16_t out_ht,
-                                          const uint16_t out_channels,
-                                          const int32_t out_offset,
-                                          const int32_t *out_shift,
-                                          const int32_t *out_mult,
-                                          const int32_t activation_min,
-                                          const int32_t activation_max);
-
-extern void esp_nn_aligned_s8_to_s16_with_offset_esp32s3(const int8_t *src, int16_t *dst,
-                                                         const int size, const int32_t offset);
-
-extern void esp_nn_s8_to_s16_esp32s3(const int8_t *src, int16_t *dst, const int size);
-
-static void esp_nn_conv_s8_unrolled(const int8_t *input_data,
-                                    const uint16_t input_wd,
-                                    const uint16_t input_ht,
-                                    const uint16_t in_channels,
-                                    const int32_t input_offset,
-                                    const uint16_t pad_wd,
-                                    const uint16_t pad_ht,
-                                    const uint16_t stride_wd,
-                                    const uint16_t stride_ht,
-                                    const int8_t *filter_data,
-                                    const uint16_t filter_wd,
-                                    const uint16_t filter_ht,
-                                    const int32_t *bias,
-                                    int8_t *out_data,
-                                    const uint16_t out_wd,
-                                    const uint16_t out_ht,
-                                    const uint16_t out_channels,
-                                    const int32_t out_offset,
-                                    const int32_t *out_shift,
-                                    const int32_t *out_mult,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max)
-{
-    int32_t out_ch_idx, out_y, out_x, in_ch_idx, filter_y_idx, filter_x_idx;
-
-    for (out_y = 0; out_y < out_ht; out_y++) {
-        for (out_x = 0; out_x < out_wd; out_x++) {
-            for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-                int32_t conv_out = 0;
-
-                const int32_t base_y = stride_ht * out_y - pad_ht;
-                const int32_t base_x = stride_wd * out_x - pad_wd;
-
-                const int32_t filter_y_start = max(0, -base_y);
-                const int32_t filter_x_start = max(0, -base_x);
-
-                const int32_t filter_y_end = min(filter_ht, input_ht - base_y);
-                const int32_t filter_x_end = min(filter_wd, input_wd - base_x);
-
-                for (filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                    for (filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                        const int32_t in_row = base_y + filter_y_idx;
-                        const int32_t in_col = base_x + filter_x_idx;
-                        int32_t input_base_offset = (in_row * input_wd + in_col) * in_channels;
-                        int32_t filter_base_offset = out_ch_idx * in_channels * filter_ht * filter_wd +
-                                                       (filter_y_idx * filter_wd + filter_x_idx) * in_channels;
-                        for (in_ch_idx = 0; in_ch_idx < in_channels; in_ch_idx++) {
-                            conv_out +=
-                                (input_data[input_base_offset + in_ch_idx] + input_offset) *
-                                filter_data[filter_base_offset + in_ch_idx];
-                        }
-                    }
-                }
-                if (bias) {
-                    conv_out += bias[out_ch_idx];
-                }
-                conv_out = esp_nn_multiply_by_quantized_mult_fast(conv_out, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                conv_out += out_offset;
-                conv_out = max(conv_out, activation_min);
-                conv_out = min(conv_out, activation_max);
-                *out_data++ = (int8_t) conv_out;
-            }
-        }
-    }
-}
-
-static void esp_nn_conv_s8_pad_valid(const int8_t *input_data,
-                                     const uint16_t input_wd,
-                                     const uint16_t input_ht,
-                                     const uint16_t in_channels,
-                                     const int32_t input_offset,
-                                     const uint16_t stride_wd,
-                                     const uint16_t stride_ht,
-                                     const int8_t *filter_data,
-                                     const uint16_t filter_wd,
-                                     const uint16_t filter_ht,
-                                     const int32_t *bias,
-                                     int8_t *out_data,
-                                     const uint16_t out_wd,
-                                     const uint16_t out_ht,
-                                     const uint16_t out_channels,
-                                     const int32_t out_offset,
-                                     const int32_t *out_shift,
-                                     const int32_t *out_mult,
-                                     const int32_t activation_min,
-                                     const int32_t activation_max)
-{
-    int32_t out_ch_idx, out_y, out_x, in_ch_idx, filter_y_idx, filter_x_idx;
-
-    for (out_y = 0; out_y < out_ht; out_y++) {
-        for (out_x = 0; out_x < out_wd; out_x++) {
-            for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-                int32_t conv_out = 0;
-
-                const int32_t base_y = stride_ht * out_y;
-                const int32_t base_x = stride_wd * out_x;
-
-                for (filter_y_idx = 0; filter_y_idx < filter_ht; filter_y_idx++) {
-                    for (filter_x_idx = 0; filter_x_idx < filter_wd; filter_x_idx++) {
-                        const int32_t in_row = base_y + filter_y_idx;
-                        const int32_t in_col = base_x + filter_x_idx;
-                        int32_t input_base_offset = (in_row * input_wd + in_col) * in_channels;
-                        int32_t filter_base_offset = out_ch_idx * in_channels * filter_ht * filter_wd +
-                                                       (filter_y_idx * filter_wd + filter_x_idx) * in_channels;
-                        const int8_t *input_data_ptr = input_data + input_base_offset;
-                        const int8_t *filter_data_ptr = filter_data + filter_base_offset;
-                        for (in_ch_idx = 0; in_ch_idx < in_channels; in_ch_idx++) {
-                            conv_out += (*input_data_ptr++ + input_offset) * *filter_data_ptr++;
-                        }
-                    }
-                }
-                if (bias) {
-                    conv_out += bias[out_ch_idx];
-                }
-                conv_out = esp_nn_multiply_by_quantized_mult_fast(conv_out, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                conv_out += out_offset;
-                conv_out = max(conv_out, activation_min);
-                conv_out = min(conv_out, activation_max);
-                *out_data++ = (int8_t) conv_out;
-            }
-        }
-    }
-}
-
-static void esp_nn_conv_s8_pad_valid_3x3(const int8_t *input_data,
-                                         const uint16_t input_wd,
-                                         const uint16_t input_ht,
-                                         const uint16_t in_channels,
-                                         const int32_t input_offset,
-                                         const uint16_t stride_wd,
-                                         const uint16_t stride_ht,
-                                         const int8_t *filter_data,
-                                         const int32_t *bias,
-                                         int8_t *out_data,
-                                         const uint16_t out_wd,
-                                         const uint16_t out_ht,
-                                         const uint16_t out_channels,
-                                         const int32_t out_offset,
-                                         const int32_t *out_shift,
-                                         const int32_t *out_mult,
-                                         const int32_t activation_min,
-                                         const int32_t activation_max)
-{
-    int32_t out_ch_idx, out_y, out_x, in_ch_idx, filter_y_idx, filter_x_idx;
-
-    for (out_y = 0; out_y < out_ht; out_y++) {
-        for (out_x = 0; out_x < out_wd; out_x++) {
-            const int32_t base_y = stride_ht * out_y;
-            const int32_t base_x = stride_wd * out_x;
-            for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-                int32_t conv_out = 0;
-                for (filter_y_idx = 0; filter_y_idx < 3; filter_y_idx++) {
-                    for (filter_x_idx = 0; filter_x_idx < 3; filter_x_idx++) {
-                        const int32_t in_row = base_y + filter_y_idx;
-                        const int32_t in_col = base_x + filter_x_idx;
-                        int32_t input_base_offset = (in_row * input_wd + in_col) * in_channels;
-                        int32_t filter_base_offset = out_ch_idx * in_channels * 3 * 3 +
-                                                       (filter_y_idx * 3 + filter_x_idx) * in_channels;
-                        const int8_t *input_data_ptr = input_data + input_base_offset;
-                        const int8_t *filter_data_ptr = filter_data + filter_base_offset;
-                        for (in_ch_idx = 0; in_ch_idx < in_channels; in_ch_idx++) {
-                            conv_out += (*input_data_ptr++ + input_offset) * *filter_data_ptr++;
-                        }
-                    }
-                }
-                if (bias) {
-                    conv_out += bias[out_ch_idx];
-                }
-                conv_out = esp_nn_multiply_by_quantized_mult_fast(conv_out, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                conv_out += out_offset;
-                conv_out = max(conv_out, activation_min);
-                conv_out = min(conv_out, activation_max);
-                *out_data++ = (int8_t) conv_out;
-            }
-        }
-    }
-}
-
-static void esp_nn_conv_s8_pad_valid_ch3_3x3(const int8_t *input_data,
-                                             const uint16_t input_wd,
-                                             const uint16_t input_ht,
-                                             const int32_t input_offset,
-                                             const uint16_t stride_wd,
-                                             const uint16_t stride_ht,
-                                             const int8_t *filter_data,
-                                             const int32_t *bias,
-                                             int8_t *out_data,
-                                             const uint16_t out_wd,
-                                             const uint16_t out_ht,
-                                             const uint16_t out_channels,
-                                             const int32_t out_offset,
-                                             const int32_t *out_shift,
-                                             const int32_t *out_mult,
-                                             const int32_t activation_min,
-                                             const int32_t activation_max)
-{
-    int32_t out_ch_idx, out_y, out_x, filter_y_idx;
-
-    /* use scratch_buffer to pre-compute offset factor */
-    int16_t *filter_sum = (int16_t *) scratch_buffer;
-    const int8_t *filter_ptr = filter_data;
-    for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-        int16_t sum_val = 0;
-        for (int i = 0; i < 9; i++) {
-            sum_val += *filter_ptr++;
-            sum_val += *filter_ptr++;
-            sum_val += *filter_ptr++;
-        }
-        *filter_sum++ = sum_val;
-    }
-
-    for (out_y = 0; out_y < out_ht; out_y++) {
-        for (out_x = 0; out_x < out_wd; out_x++) {
-            const int8_t *filter_data_ptr = filter_data;
-            const int32_t base_y = stride_ht * out_y;
-            const int32_t base_x = stride_wd * out_x;
-            const int8_t *input_base_ptr = input_data + (base_y * input_wd + base_x) * 3;
-            int16_t *filter_sum = (int16_t *) scratch_buffer;
-            for (out_ch_idx = 0; out_ch_idx < out_channels; out_ch_idx++) {
-                int32_t conv_out = 0;
-
-                for (filter_y_idx = 0; filter_y_idx < 3; filter_y_idx++) {
-                    const int8_t *input_data_ptr = input_base_ptr + (filter_y_idx * input_wd) * 3;
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                    conv_out += (*input_data_ptr++) * (*filter_data_ptr++);
-                }
-
-                conv_out += *filter_sum++ * input_offset;
-
-                if (bias) {
-                    conv_out += bias[out_ch_idx];
-                }
-                conv_out = esp_nn_multiply_by_quantized_mult_fast(conv_out, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                conv_out += out_offset;
-                conv_out = max(conv_out, activation_min);
-                conv_out = min(conv_out, activation_max);
-                *out_data++ = (int8_t) conv_out;
-            }
-        }
-    }
-}
-
-int esp_nn_get_conv_scratch_size_esp32s3(const uint16_t input_wd,
-                                         const uint16_t input_ht,
-                                         const uint16_t in_ch,
-                                         const uint16_t out_ch,
-                                         const uint16_t filter_wd,
-                                         const uint16_t filter_ht)
-{
-    int filter_size = filter_wd * filter_ht * in_ch * out_ch;
-    int input_size = input_wd * input_ht * in_ch;
-    int transpose_buf_size = 8 * in_ch; /* to store intermediate data */
-    int align_buf_size = 32; /* extra buffer for alignment */
-    return 2 * (filter_size + input_size +  transpose_buf_size) + align_buf_size;
-}
-
-void esp_nn_set_conv_scratch_buf_esp32s3(void *buf)
-{
-    scratch_buffer = (int16_t *) buf;
-}
-
-void esp_nn_conv_s8_esp32s3(const int8_t *input,
-                            const uint16_t input_wd,
-                            const uint16_t input_ht,
-                            const uint16_t channels,
-                            const int32_t input_offset,
-                            const uint16_t pad_wd,
-                            const uint16_t pad_ht,
-                            const uint16_t stride_wd,
-                            const uint16_t stride_ht,
-                            const int8_t *filter_data,
-                            const uint16_t filter_wd,
-                            const uint16_t filter_ht,
-                            const int32_t *bias,
-                            int8_t *out_data,
-                            const uint16_t out_wd,
-                            const uint16_t out_ht,
-                            const uint16_t out_channels,
-                            const int32_t out_offset,
-                            const int32_t *out_shift,
-                            const int32_t *out_mult,
-                            const int32_t activation_min,
-                            const int32_t activation_max)
-{
-    int filter_size = filter_wd * filter_ht * channels * out_channels;
-    int input_size = input_wd * input_ht * channels;
-    int align_len = 16 - (filter_size & 15);
-    int16_t *filter_data16 = scratch_buffer;
-    int16_t *input_data16 = scratch_buffer + filter_size + align_len;
-
-    if (scratch_buffer == NULL) {
-        printf("esp_nn_conv error! scratch_buffer not set!\n");
-        return;
-    }
-
-    if (channels % 8 == 0 && filter_wd == 1 && filter_ht == 1 &&
-            pad_wd == 0 && pad_ht == 0 && stride_wd == 1 && stride_ht == 1) {
-        int scratch_offset = (int) (filter_data16 + filter_size);
-        void *scratch_buf = (void *) (scratch_offset + 16 - (scratch_offset & 15));
-        esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-        esp_nn_conv_s16_mult8_1x1_esp32s3(
-            input, input_wd, input_ht, channels, input_offset, filter_data16,
-            bias, out_data, out_wd, out_ht, out_channels, out_offset,
-            out_shift, out_mult, activation_min, activation_max, scratch_buf);
-    } else if (channels % 4 == 0 && filter_wd == 1 && filter_ht == 1 &&
-            (input_wd * input_ht) % 16 == 0 && /* TODO: remove this check */
-            pad_wd == 0 && pad_ht == 0 && stride_wd == 1 && stride_ht == 1) {
-        int scratch_offset = (int) (input_data16 + input_size);
-        void *scratch_buf = (void *) (scratch_offset + 16 - (scratch_offset & 15));
-        esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-        esp_nn_aligned_s8_to_s16_with_offset_esp32s3(input, input_data16, input_size, input_offset);
-        esp_nn_conv_s16_mult4_1x1_esp32s3(
-            input_data16, input_wd, input_ht, channels, filter_data16,
-            bias, out_data, out_wd, out_ht, out_channels, out_offset,
-            out_shift, out_mult, activation_min, activation_max, scratch_buf);
-    } else if (channels % 8 == 0) {
-        esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-        esp_nn_aligned_s8_to_s16_with_offset_esp32s3(input, input_data16, input_size, input_offset);
-        esp_nn_conv_s16_mult8_esp32s3(
-            input_data16, input_wd, input_ht, channels, pad_wd, pad_ht,
-            stride_wd, stride_ht, filter_data16, filter_wd, filter_ht, bias,
-            out_data, out_wd, out_ht, out_channels, out_offset, out_shift,
-            out_mult, activation_min, activation_max);
-    } else if (pad_wd == 0 && pad_ht == 0) {
-        if (filter_wd == 3 && filter_ht == 3 && channels == 3) {
-            esp_nn_conv_s8_pad_valid_ch3_3x3(input, input_wd, input_ht, input_offset,
-                                             stride_wd, stride_ht, filter_data, bias,
-                                             out_data, out_wd, out_ht, out_channels, out_offset,
-                                             out_shift, out_mult, activation_min, activation_max);
-        } else {
-            esp_nn_conv_s8_pad_valid(input, input_wd, input_ht, channels, input_offset,
-                                     stride_wd, stride_ht, filter_data, filter_wd, filter_ht, bias,
-                                     out_data, out_wd, out_ht, out_channels, out_offset, out_shift,
-                                     out_mult, activation_min, activation_max);
-        }
-    } else {
-        /* Basic unrolled version */
-        esp_nn_conv_s8_unrolled(input, input_wd, input_ht, channels, input_offset,
-                                pad_wd, pad_ht, stride_wd, stride_ht,
-                                filter_data, filter_wd, filter_ht, bias,
-                                out_data, out_wd, out_ht, out_channels, out_offset, out_shift,
-                                out_mult, activation_min, activation_max);
-    }
-}

code/components/esp-nn/src/convolution/esp_nn_depthwise_conv_ansi.c

@@ -1,97 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-int esp_nn_get_depthwise_conv_scratch_size_ansi(const uint16_t input_wd,
-                                                const uint16_t input_ht,
-                                                const uint16_t channels,
-                                                const uint16_t ch_mult,
-                                                const uint16_t filter_wd,
-                                                const uint16_t filter_ht)
-{
-    return 0;
-}
-
-void esp_nn_set_depthwise_conv_scratch_buf_ansi(const void *buf)
-{
-
-}
-
-void esp_nn_depthwise_conv_s8_ansi(const int8_t *input_data,
-                                   const uint16_t input_wd,
-                                   const uint16_t input_ht,
-                                   const uint16_t channels,
-                                   const int32_t input_offset,
-                                   const uint16_t pad_wd,
-                                   const uint16_t pad_ht,
-                                   const uint16_t stride_wd,
-                                   const uint16_t stride_ht,
-                                   const uint16_t ch_mult,
-                                   const int8_t *filter_data,
-                                   const uint16_t filter_wd,
-                                   const uint16_t filter_ht,
-                                   const int32_t *bias,
-                                   int8_t *out_data,
-                                   const uint16_t out_wd,
-                                   const uint16_t out_ht,
-                                   const int32_t out_offset,
-                                   const int32_t *out_shift,
-                                   const int32_t *out_mult,
-                                   const int32_t activation_min,
-                                   const int32_t activation_max)
-{
-    int out_idx = 0;
-    for (int out_y = 0; out_y < out_ht; out_y++) { //height loop
-        const int16_t base_y = (out_y * stride_ht) - pad_ht;
-        for (int out_x = 0; out_x < out_wd; out_x++) { //width_loop
-            const int16_t base_x = (out_x * stride_wd) - pad_wd;
-            for (int ch_idx = 0; ch_idx < channels; ch_idx++) {//channel_loop
-                for (int ch_mult_idx = 0; ch_mult_idx < ch_mult; ch_mult_idx++) {
-                    int32_t result = 0;
-                    const int out_ch_idx = ch_mult_idx + ch_idx * ch_mult;
-
-                    /* Select filter so as the point doesn't lie outside block */
-                    int filter_y_start = max(0, -base_y);
-                    int filter_x_start = max(0, -base_x);
-                    int filter_y_end = min(filter_ht, input_ht - base_y);
-                    int filter_x_end = min(filter_wd, input_wd - base_x);
-
-                    for (int filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                        const int32_t idx_y = base_y + filter_y_idx;
-                        for (int filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                            const int32_t idx_x = base_x + filter_x_idx;
-                            int32_t input_index = (idx_y * input_wd + idx_x) * channels + ch_idx;
-                            int32_t filter_index = (filter_y_idx * filter_wd + filter_x_idx) * (channels * ch_mult) + out_ch_idx;
-                            int32_t input_val = input_data[input_index] + input_offset;
-                            int32_t filter_val = filter_data[filter_index];
-                            result += input_val * filter_val;
-                        }
-                    }
-                    if (bias) {
-                        result += bias[out_ch_idx];
-                    }
-                    result = esp_nn_multiply_by_quantized_mult(result, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                    result += out_offset;
-                    result = max(result, activation_min);
-                    result = min(result, activation_max);
-
-                    out_data[out_idx++] = result;
-                }
-            }
-        }
-    }
-}

code/components/esp-nn/src/convolution/esp_nn_depthwise_conv_s8_esp32s3.c

@@ -1,483 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdio.h>
-
-#include <common_functions.h>
-
-static int16_t *scratch_buffer = NULL;
-
-extern void esp_nn_depthwise_conv_s16_mult8_3x3_esp32s3(const int16_t *input_data,
-                                                        const uint16_t input_wd,
-                                                        const uint16_t input_ht,
-                                                        const uint16_t channels,
-                                                        const uint16_t pad_wd,
-                                                        const uint16_t pad_ht,
-                                                        const uint16_t stride_wd,
-                                                        const uint16_t stride_ht,
-                                                        const uint16_t ch_mult,
-                                                        const int16_t *filter_data,
-                                                        const int32_t *bias,
-                                                        int8_t *out_data,
-                                                        const uint16_t out_wd,
-                                                        const uint16_t out_ht,
-                                                        const int32_t out_offset,
-                                                        const int32_t *out_shift,
-                                                        const int32_t *out_mult,
-                                                        const int32_t activation_min,
-                                                        const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s8_mult1_3x3_padded_esp32s3(const int8_t *input_data,
-                                                              const uint16_t input_wd,
-                                                              const uint16_t input_ht,
-                                                              const uint16_t channels,
-                                                              const int32_t input_offset,
-                                                              const uint16_t stride_wd,
-                                                              const uint16_t stride_ht,
-                                                              const int8_t *filter_data,
-                                                              const int32_t *bias,
-                                                              int8_t *out_data,
-                                                              const uint16_t out_wd,
-                                                              const uint16_t out_ht,
-                                                              const int32_t out_offset,
-                                                              const int32_t *out_shift,
-                                                              const int32_t *out_mult,
-                                                              const int32_t activation_min,
-                                                              const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s16_mult1_3x3_no_pad_esp32s3(const int16_t *input_data,
-                                                               const uint16_t input_wd,
-                                                               const uint16_t input_ht,
-                                                               const uint16_t channels,
-                                                               const uint16_t stride_wd,
-                                                               const uint16_t stride_ht,
-                                                               const int16_t *filter_data,
-                                                               const int32_t *bias,
-                                                               int8_t *out_data,
-                                                               const uint16_t out_wd,
-                                                               const uint16_t out_ht,
-                                                               const int32_t out_offset,
-                                                               const int32_t *out_shift,
-                                                               const int32_t *out_mult,
-                                                               const int32_t activation_min,
-                                                               const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s16_mult8_esp32s3(const int16_t *input_data,
-                                                    const uint16_t input_wd,
-                                                    const uint16_t input_ht,
-                                                    const uint16_t channels,
-                                                    const uint16_t pad_wd,
-                                                    const uint16_t pad_ht,
-                                                    const uint16_t stride_wd,
-                                                    const uint16_t stride_ht,
-                                                    const uint16_t ch_mult,
-                                                    const int16_t *filter_data,
-                                                    const uint16_t filter_wd,
-                                                    const uint16_t filter_ht,
-                                                    const int32_t *bias,
-                                                    int8_t *out_data,
-                                                    const uint16_t out_wd,
-                                                    const uint16_t out_ht,
-                                                    const int32_t out_offset,
-                                                    const int32_t *out_shift,
-                                                    const int32_t *out_mult,
-                                                    const int32_t activation_min,
-                                                    const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s16_mult4_esp32s3(const int16_t *input_data,
-                                                    const uint16_t input_wd,
-                                                    const uint16_t input_ht,
-                                                    const uint16_t channels,
-                                                    const uint16_t pad_wd,
-                                                    const uint16_t pad_ht,
-                                                    const uint16_t stride_wd,
-                                                    const uint16_t stride_ht,
-                                                    const uint16_t ch_mult,
-                                                    const int16_t *filter_data,
-                                                    const uint16_t filter_wd,
-                                                    const uint16_t filter_ht,
-                                                    const int32_t *bias,
-                                                    int8_t *out_data,
-                                                    const uint16_t out_wd,
-                                                    const uint16_t out_ht,
-                                                    const int32_t out_offset,
-                                                    const int32_t *out_shift,
-                                                    const int32_t *out_mult,
-                                                    const int32_t activation_min,
-                                                    const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s16_mult1_3x3_esp32s3(const int16_t *input_data,
-                                                        const uint16_t input_wd,
-                                                        const uint16_t input_ht,
-                                                        const uint16_t channels,
-                                                        const uint16_t pad_wd,
-                                                        const uint16_t pad_ht,
-                                                        const uint16_t stride_wd,
-                                                        const uint16_t stride_ht,
-                                                        const int16_t *filter_data,
-                                                        const int32_t *bias,
-                                                        int8_t *out_data,
-                                                        const uint16_t out_wd,
-                                                        const uint16_t out_ht,
-                                                        const int32_t out_offset,
-                                                        const int32_t *out_shift,
-                                                        const int32_t *out_mult,
-                                                        const int32_t activation_min,
-                                                        const int32_t activation_max);
-
-extern void esp_nn_depthwise_conv_s16_mult1_esp32s3(const int16_t *input_data,
-                                                    const uint16_t input_wd,
-                                                    const uint16_t input_ht,
-                                                    const uint16_t channels,
-                                                    const uint16_t pad_wd,
-                                                    const uint16_t pad_ht,
-                                                    const uint16_t stride_wd,
-                                                    const uint16_t stride_ht,
-                                                    const int16_t *filter_data,
-                                                    const uint16_t filter_wd,
-                                                    const uint16_t filter_ht,
-                                                    const int32_t *bias,
-                                                    int8_t *out_data,
-                                                    const uint16_t out_wd,
-                                                    const uint16_t out_ht,
-                                                    const int32_t out_offset,
-                                                    const int32_t *out_shift,
-                                                    const int32_t *out_mult,
-                                                    const int32_t activation_min,
-                                                    const int32_t activation_max);
-
-extern void esp_nn_s8_to_s16_esp32s3(const int8_t *src, int16_t *dst, const int size);
-
-extern void esp_nn_aligned_s8_to_s16_with_offset_esp32s3(const int8_t *src, int16_t *dst,
-                                                         const int size, const int32_t offset);
-
-static void esp_nn_depthwise_conv_s8_unrolled(const int8_t *input_data,
-                                              const uint16_t input_wd,
-                                              const uint16_t input_ht,
-                                              const uint16_t channels,
-                                              const int32_t input_offset,
-                                              const uint16_t pad_wd,
-                                              const uint16_t pad_ht,
-                                              const uint16_t stride_wd,
-                                              const uint16_t stride_ht,
-                                              const uint16_t ch_mult,
-                                              const int8_t *filter_data,
-                                              const uint16_t filter_wd,
-                                              const uint16_t filter_ht,
-                                              const int32_t *bias,
-                                              int8_t *out_data,
-                                              const uint16_t out_wd,
-                                              const uint16_t out_ht,
-                                              const int32_t out_offset,
-                                              const int32_t *out_shift,
-                                              const int32_t *out_mult,
-                                              const int32_t activation_min,
-                                              const int32_t activation_max)
-{
-    int out_idx = 0;
-    for (int out_y = 0; out_y < out_ht; out_y++) { //height loop
-        const int16_t base_y = (out_y * stride_ht) - pad_ht;
-        for (int out_x = 0; out_x < out_wd; out_x++) { //width_loop
-            const int16_t base_x = (out_x * stride_wd) - pad_wd;
-            for (int ch_idx = 0; ch_idx < channels; ch_idx++) {//channel_loop
-                int ch_mult_idx = 0;
-                for (; ch_mult_idx < ch_mult - 3; ch_mult_idx += 4) {
-                    int32_t result0 = 0, result1 = 0, result2 = 0, result3 = 0;
-                    const int out_ch_idx = ch_mult_idx + ch_idx * ch_mult;
-
-                    /* Select filter so as the point doesn't lie outside block */
-                    int filter_y_start = max(0, -base_y);
-                    int filter_x_start = max(0, -base_x);
-                    int filter_y_end = min(filter_ht, input_ht - base_y);
-                    int filter_x_end = min(filter_wd, input_wd - base_x);
-
-                    for (int filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                        const int32_t idx_y = base_y + filter_y_idx;
-                        for (int filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                            const int32_t idx_x = base_x + filter_x_idx;
-                            int32_t input_index = (idx_y * input_wd + idx_x) * channels + ch_idx;
-                            int32_t filter_index = (filter_y_idx * filter_wd + filter_x_idx) * (channels * ch_mult) + out_ch_idx;
-                            int32_t input_val = input_data[input_index] + input_offset;
-                            int32_t filter_val0 = filter_data[filter_index + 0];
-                            int32_t filter_val1 = filter_data[filter_index + 1];
-                            int32_t filter_val2 = filter_data[filter_index + 2];
-                            int32_t filter_val3 = filter_data[filter_index + 3];
-                            result0 += input_val * filter_val0;
-                            result1 += input_val * filter_val1;
-                            result2 += input_val * filter_val2;
-                            result3 += input_val * filter_val3;
-                        }
-                    }
-                    if (bias) {
-                        result0 += bias[out_ch_idx + 0];
-                        result1 += bias[out_ch_idx + 1];
-                        result2 += bias[out_ch_idx + 2];
-                        result3 += bias[out_ch_idx + 3];
-                    }
-                    result0 = esp_nn_multiply_by_quantized_mult(result0,
-                                out_mult[out_ch_idx + 0], out_shift[out_ch_idx + 0]);
-                    result1 = esp_nn_multiply_by_quantized_mult(result1,
-                                out_mult[out_ch_idx + 1], out_shift[out_ch_idx + 1]);
-                    result2 = esp_nn_multiply_by_quantized_mult(result2,
-                                out_mult[out_ch_idx + 2], out_shift[out_ch_idx + 2]);
-                    result3 = esp_nn_multiply_by_quantized_mult(result3,
-                                out_mult[out_ch_idx + 3], out_shift[out_ch_idx + 3]);
-
-                    result0 += out_offset;
-                    result1 += out_offset;
-                    result2 += out_offset;
-                    result3 += out_offset;
-
-                    result0 = max(result0, activation_min);
-                    result1 = max(result1, activation_min);
-                    result2 = max(result2, activation_min);
-                    result3 = max(result3, activation_min);
-
-                    result0 = min(result0, activation_max);
-                    result1 = min(result1, activation_max);
-                    result2 = min(result2, activation_max);
-                    result3 = min(result3, activation_max);
-
-                    out_data[out_idx++] = result0;
-                    out_data[out_idx++] = result1;
-                    out_data[out_idx++] = result2;
-                    out_data[out_idx++] = result3;
-                }
-
-                /* left-over */
-                for (; ch_mult_idx < ch_mult; ch_mult_idx++) {
-                    int32_t result = 0;
-                    const int out_ch_idx = ch_mult_idx + ch_idx * ch_mult;
-
-                    /* Select filter so as the point doesn't lie outside block */
-                    int filter_y_start = max(0, -base_y);
-                    int filter_x_start = max(0, -base_x);
-                    int filter_y_end = min(filter_ht, input_ht - base_y);
-                    int filter_x_end = min(filter_wd, input_wd - base_x);
-
-                    for (int filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                        const int32_t idx_y = base_y + filter_y_idx;
-                        for (int filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                            const int32_t idx_x = base_x + filter_x_idx;
-                            int32_t input_index = (idx_y * input_wd + idx_x) * channels + ch_idx;
-                            int32_t filter_index = (filter_y_idx * filter_wd + filter_x_idx) * (channels * ch_mult) + out_ch_idx;
-                            int32_t input_val = input_data[input_index] + input_offset;
-                            int32_t filter_val = filter_data[filter_index];
-                            result += input_val * filter_val;
-                        }
-                    }
-                    if (bias) {
-                        result += bias[out_ch_idx];
-                    }
-                    result = esp_nn_multiply_by_quantized_mult(result, out_mult[out_ch_idx], out_shift[out_ch_idx]);
-                    result += out_offset;
-                    result = max(result, activation_min);
-                    result = min(result, activation_max);
-
-                    out_data[out_idx++] = result;
-                }
-            }
-        }
-    }
-}
-
-void esp_nn_depthwise_conv_s8_ch_mult1(const int8_t *input_data,
-                                       const uint16_t input_wd,
-                                       const uint16_t input_ht,
-                                       const uint16_t channels,
-                                       const int32_t input_offset,
-                                       const uint16_t pad_wd,
-                                       const uint16_t pad_ht,
-                                       const uint16_t stride_wd,
-                                       const uint16_t stride_ht,
-                                       const int8_t *filter_data,
-                                       const uint16_t filter_wd,
-                                       const uint16_t filter_ht,
-                                       const int32_t *bias,
-                                       int8_t *out_data,
-                                       const uint16_t out_wd,
-                                       const uint16_t out_ht,
-                                       const int32_t out_offset,
-                                       const int32_t *out_shift,
-                                       const int32_t *out_mult,
-                                       const int32_t activation_min,
-                                       const int32_t activation_max)
-{
-    int out_idx = 0;
-    for (int out_y = 0; out_y < out_ht; out_y++) { //height loop
-        const int16_t base_y = (out_y * stride_ht) - pad_ht;
-        for (int out_x = 0; out_x < out_wd; out_x++) { //width_loop
-            const int16_t base_x = (out_x * stride_wd) - pad_wd;
-            for (int ch_idx = 0; ch_idx < channels; ch_idx++) {//channel_loop
-                int32_t result = 0;
-                /* Select filter so as the point doesn't lie outside block */
-                int filter_y_start = max(0, -base_y);
-                int filter_x_start = max(0, -base_x);
-                int filter_y_end = min(filter_ht, input_ht - base_y);
-                int filter_x_end = min(filter_wd, input_wd - base_x);
-
-                for (int filter_y_idx = filter_y_start; filter_y_idx < filter_y_end; filter_y_idx++) {
-                    const int32_t idx_y = base_y + filter_y_idx;
-                    for (int filter_x_idx = filter_x_start; filter_x_idx < filter_x_end; filter_x_idx++) {
-                        const int32_t idx_x = base_x + filter_x_idx;
-                        int32_t input_index = (idx_y * input_wd + idx_x) * channels + ch_idx;
-                        int32_t filter_index = (filter_y_idx * filter_wd + filter_x_idx) * channels + ch_idx;
-                        int32_t input_val = input_data[input_index] + input_offset;
-                        int32_t filter_val = filter_data[filter_index];
-                        result += input_val * filter_val;
-                    }
-                }
-                if (bias) {
-                    result += bias[ch_idx];
-                }
-                result = esp_nn_multiply_by_quantized_mult(result, out_mult[ch_idx], out_shift[ch_idx]);
-                result += out_offset;
-                result = max(result, activation_min);
-                result = min(result, activation_max);
-
-                out_data[out_idx++] = result;
-            }
-        }
-    }
-}
-
-int esp_nn_get_depthwise_conv_scratch_size_esp32s3(const uint16_t input_wd,
-                                                   const uint16_t input_ht,
-                                                   const uint16_t channels,
-                                                   const uint16_t ch_mult,
-                                                   const uint16_t filter_wd,
-                                                   const uint16_t filter_ht)
-{
-    int filter_size = filter_wd * filter_ht * channels * ch_mult;
-    int padding_used = ((filter_wd == 3) && (filter_ht == 3)) * 2;
-    int input_size = (input_wd + padding_used) * (input_ht + padding_used) * channels;
-    return  2 * (filter_size + input_size) + 16; //16 for alignment
-}
-
-void esp_nn_set_depthwise_conv_scratch_buf_esp32s3(void *buf)
-{
-    scratch_buffer = (int16_t *) buf;
-}
-
-/**
- * Assumption 1: i/p channels == o/p channels
- * Assumption 2: Pointers are valid
- * Assumption 3: dialation width = 1
- */
-void esp_nn_depthwise_conv_s8_esp32s3(const int8_t *input_data,
-                                      const uint16_t input_wd,
-                                      const uint16_t input_ht,
-                                      const uint16_t channels,
-                                      const int32_t input_offset,
-                                      const uint16_t pad_wd,
-                                      const uint16_t pad_ht,
-                                      const uint16_t stride_wd,
-                                      const uint16_t stride_ht,
-                                      const uint16_t ch_mult,
-                                      const int8_t *filter_data,
-                                      const uint16_t filter_wd,
-                                      const uint16_t filter_ht,
-                                      const int32_t *bias,
-                                      int8_t *out_data,
-                                      const uint16_t out_wd,
-                                      const uint16_t out_ht,
-                                      const int32_t out_offset,
-                                      const int32_t *out_shift,
-                                      const int32_t *out_mult,
-                                      const int32_t activation_min,
-                                      const int32_t activation_max)
-{
-    int filter_size = filter_wd * filter_ht * channels * ch_mult;
-    int align_len = 16 - (filter_size & 15);
-    int input_size = input_wd * input_ht * channels;
-    int16_t *filter_data16 = scratch_buffer;
-    int16_t *input_data16 = scratch_buffer + filter_size + align_len;
-    if (scratch_buffer == NULL) {
-        printf("esp_nn_depthwise_conv error! scratch_buffer not set!\n");
-        return;
-    }
-
-    if ((ch_mult == 1) && (channels % 8 == 0)) {
-        if ((filter_wd == 3) && (filter_ht == 3)) {
-            if ((channels % 16 == 0) && (pad_wd == 1) && (pad_ht == 1)) {
-                /* process in 8 bits */
-                int8_t *filter_aligned = (int8_t *) scratch_buffer;
-                int8_t *input_padded = (int8_t *) scratch_buffer + filter_size + align_len;
-                memcpy(filter_aligned, filter_data, filter_size);
-                esp_nn_aligned_s8_pad_with_value(input_data, input_padded, input_wd, input_ht, channels,
-                                                 -input_offset, pad_wd, pad_ht);
-                esp_nn_depthwise_conv_s8_mult1_3x3_padded_esp32s3(input_padded, input_wd + 2 * pad_wd,
-                                                                  input_ht + 2 * pad_ht, channels, input_offset,
-                                                                  stride_wd, stride_ht, filter_aligned, bias,
-                                                                  out_data, out_wd, out_ht, out_offset, out_shift,
-                                                                  out_mult, activation_min, activation_max);
-            } else if ((pad_wd == 0) && (pad_ht == 0) &&
-                    // because this does not handle padding offset cases yet, run just for stride (1, 1).
-                    // end padding of input with `-input_offset` should solve this
-                    (stride_wd == 1) && (stride_ht == 1)) {
-                /* process in 8 bits */
-                int8_t *filter_aligned = (int8_t *) scratch_buffer;
-                memcpy(filter_aligned, filter_data, filter_size);
-                esp_nn_depthwise_conv_s8_mult1_3x3_padded_esp32s3(input_data, input_wd, input_ht, channels, input_offset,
-                                                                  stride_wd, stride_ht, filter_aligned,
-                                                                  bias, out_data, out_wd, out_ht, out_offset, out_shift,
-                                                                  out_mult, activation_min, activation_max);
-            } else { /* (channels % 8) == 0 && pad_wd == 1 && pad_ht == 1 */
-                esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-                esp_nn_aligned_s8_to_s16_with_offset_esp32s3(input_data, input_data16, input_size, input_offset);
-                esp_nn_depthwise_conv_s16_mult1_3x3_esp32s3(input_data16, input_wd, input_ht, channels,
-                                                            pad_wd, pad_ht, stride_wd, stride_ht, filter_data16,
-                                                            bias, out_data, out_wd, out_ht, out_offset, out_shift,
-                                                            out_mult, activation_min, activation_max);
-            }
-        } else { // all other ch_mult == 1, `channels % 8 == 0`
-            esp_nn_depthwise_conv_s8_ch_mult1(input_data, input_wd, input_ht, channels, input_offset,
-                                              pad_wd, pad_ht, stride_wd, stride_ht,
-                                              filter_data, filter_wd, filter_ht,
-                                              bias, out_data, out_wd, out_ht, out_offset, out_shift,
-                                              out_mult, activation_min, activation_max);
-        }
-    } else if (ch_mult % 8 == 0) {
-        esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-        esp_nn_aligned_s8_to_s16_with_offset_esp32s3(input_data, input_data16, input_size, input_offset);
-        if (filter_wd == 3 && filter_ht == 3) {
-            esp_nn_depthwise_conv_s16_mult8_3x3_esp32s3(input_data16, input_wd, input_ht, channels,
-                                                        pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                                        filter_data16, bias,
-                                                        out_data, out_wd, out_ht, out_offset, out_shift,
-                                                        out_mult, activation_min, activation_max);
-        } else {
-            esp_nn_depthwise_conv_s16_mult8_esp32s3(input_data16, input_wd, input_ht, channels,
-                                                    pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                                    filter_data16, filter_wd, filter_ht, bias,
-                                                    out_data, out_wd, out_ht, out_offset, out_shift,
-                                                    out_mult, activation_min, activation_max);
-        }
-    } else if (ch_mult % 4 == 0) {
-        esp_nn_s8_to_s16_esp32s3(filter_data, filter_data16, filter_size);
-        esp_nn_aligned_s8_to_s16_with_offset_esp32s3(input_data, input_data16, input_size, input_offset);
-        esp_nn_depthwise_conv_s16_mult4_esp32s3(input_data16, input_wd, input_ht, channels,
-                                                pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                                filter_data16, filter_wd, filter_ht, bias,
-                                                out_data, out_wd, out_ht, out_offset, out_shift,
-                                                out_mult, activation_min, activation_max);
-    } else {
-        esp_nn_depthwise_conv_s8_unrolled(input_data, input_wd, input_ht, channels, input_offset,
-                                          pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                          filter_data, filter_wd, filter_ht,
-                                          bias, out_data, out_wd, out_ht, out_offset, out_shift,
-                                          out_mult, activation_min, activation_max);
-    }
-}

code/components/esp-nn/src/fully_connected/esp_nn_fully_connected_ansi.c

@@ -1,50 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-void esp_nn_fully_connected_s8_ansi(const int8_t *input_data,
-                                    const int32_t input_offset,
-                                    const uint16_t row_len,
-                                    const int8_t *filter_data,
-                                    const int32_t filter_offset,
-                                    const int32_t *bias,
-                                    int8_t *out_data,
-                                    const uint16_t out_channels,
-                                    const int32_t out_offset,
-                                    const int32_t out_shift,
-                                    const int32_t out_mult,
-                                    const int32_t activation_min,
-                                    const int32_t activation_max)
-{
-    for (int32_t out_c = 0; out_c < out_channels; ++out_c) {
-        int32_t result = 0;
-        for (int32_t data_idx = 0; data_idx < row_len; data_idx++) {
-            int32_t filter_index = row_len * out_c + data_idx;
-            int32_t input_val = input_data[data_idx];
-            int32_t filter_val = filter_data[filter_index];
-            result += (filter_val + filter_offset) * (input_val + input_offset);
-        }
-        if (bias) {
-            result += bias[out_c];
-        }
-        result = esp_nn_multiply_by_quantized_mult(result, out_mult, out_shift);
-        result += out_offset;
-        result = max(result, activation_min);
-        result = min(result, activation_max);
-        out_data[out_c] = (int8_t) result;
-    }
-}

code/components/esp-nn/src/pooling/esp_nn_avg_pool_ansi.c

@@ -1,72 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-void esp_nn_avg_pool_s8_ansi(const int8_t *input,
-                             const uint16_t input_wd,
-                             const uint16_t input_ht,
-                             int8_t *output,
-                             const uint16_t output_wd,
-                             const uint16_t output_ht,
-                             const uint16_t stride_wd,
-                             const uint16_t stride_ht,
-                             const uint16_t filter_wd,
-                             const uint16_t filter_ht,
-                             const uint16_t pad_wd,
-                             const uint16_t pad_ht,
-                             const int32_t activation_min,
-                             const int32_t activation_max,
-                             const uint16_t channels)
-{
-    int32_t base_y = -pad_ht;
-    for (int32_t out_y = 0; out_y < output_ht; out_y++, base_y += stride_ht) {
-        int32_t base_x = -pad_wd;
-        for (int32_t out_x = 0; out_x < output_wd; out_x++, base_x += stride_wd) {
-            for (int32_t ch_idx = 0; ch_idx < channels; ch_idx++) {
-                int32_t result = 0;
-                int32_t filter_cnt = 0;
-                /* Make sure filter does not cross the input box */
-                int32_t filter_y_start = max(0, -base_y);
-                int32_t filter_x_start = max(0, -base_x);
-
-                int32_t filter_y_end = min(filter_ht, input_ht - base_y);
-                int32_t filter_x_end = min(filter_wd, input_wd - base_x);
-
-                for (int32_t filter_y = filter_y_start; filter_y < filter_y_end; filter_y++) {
-                    for (int32_t filter_x = filter_x_start; filter_x < filter_x_end; filter_x++) {
-                        int32_t in_x_idx = base_x + filter_x;
-                        int32_t in_y_idx = base_y + filter_y;
-                        int32_t input_index = (in_y_idx * input_wd + in_x_idx) * channels + ch_idx;
-                        result += input[input_index];
-                        filter_cnt++;
-                    }
-                }
-
-                /* Rounded average */
-                result = result > 0 ? (result + filter_cnt / 2) / filter_cnt
-                                    : (result - filter_cnt / 2) / filter_cnt;
-
-                /* Activation function */
-                result = max(result, activation_min);
-                result = min(result, activation_max);
-
-                int32_t output_index = (out_y * output_wd + out_x) * channels + ch_idx;
-                output[output_index] = (int8_t) result;
-            }
-        }
-    }
-}

code/components/esp-nn/src/pooling/esp_nn_max_pool_ansi.c

@@ -1,66 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-
-#include <common_functions.h>
-
-void esp_nn_max_pool_s8_ansi(const int8_t *input,
-                             const uint16_t input_wd,
-                             const uint16_t input_ht,
-                             int8_t *output,
-                             const uint16_t output_wd,
-                             const uint16_t output_ht,
-                             const uint16_t stride_wd,
-                             const uint16_t stride_ht,
-                             const uint16_t filter_wd,
-                             const uint16_t filter_ht,
-                             const uint16_t pad_wd,
-                             const uint16_t pad_ht,
-                             const int32_t activation_min,
-                             const int32_t activation_max,
-                             const uint16_t channels)
-{
-    int32_t base_y = -pad_ht;
-    for (int32_t out_y = 0; out_y < output_ht; out_y++, base_y += stride_ht) {
-        int32_t base_x = -pad_wd;
-        for (int32_t out_x = 0; out_x < output_wd; out_x++, base_x += stride_wd) {
-            /* Make sure filter does not cross the input box */
-            int32_t filter_y_start = max(0, -base_y);
-            int32_t filter_x_start = max(0, -base_x);
-            int32_t filter_y_end = min(filter_ht, input_ht - base_y);
-            int32_t filter_x_end = min(filter_wd, input_wd - base_x);
-
-            for (int32_t ch_idx = 0; ch_idx < channels; ch_idx++) {
-                int8_t result = INT8_MIN;
-
-                for (int32_t filter_y = filter_y_start; filter_y < filter_y_end; filter_y++) {
-                    for (int32_t filter_x = filter_x_start; filter_x < filter_x_end; filter_x++) {
-                        int32_t in_x_idx = base_x + filter_x;
-                        int32_t in_y_idx = base_y + filter_y;
-                        int32_t input_index = (in_y_idx * input_wd + in_x_idx) * channels + ch_idx;
-                        result = max(input[input_index], result);
-                    }
-                }
-
-                /* Activation function */
-                result = max(result, activation_min);
-                result = min(result, activation_max);
-
-                int32_t output_index = (out_y * output_wd + out_x) * channels + ch_idx;
-                output[output_index] = result;
-            }
-        }
-    }
-}

code/components/esp-nn/src/softmax/esp_nn_softmax_ansi.c

@@ -1,88 +0,0 @@
-// Copyright 2022 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 "softmax_common.h"
-
-int32_t esp_nn_get_softmax_scratch_size_ansi(const int32_t width, const int32_t height)
-{
-    (void) width;
-    (void) height;
-    return 0;
-}
-
-void esp_nn_set_softmax_scratch_buf_ansi(void *buffer)
-{
-    (void) buffer;
-    return;
-}
-
-void esp_nn_softmax_s8_ansi(const int8_t *input_data,
-                            const int32_t height,
-                            const int32_t width,
-                            const int32_t mult,
-                            const int32_t shift,
-                            const int32_t diff_min,
-                            int8_t *output_data)
-{
-    // The representation chosen for the input to the exp() function is Q5.26.
-    // We need to leave extra space since values that we skip might be as large as
-    // -32 before multiplying by input mult, and therefore as large as
-    // -16 afterwards.  Note that exp(-8) is definitely not insignificant to
-    // accumulation, but exp(-16) definitely is.
-#define ACCUM_BITS  12
-#define DIFF_BITS   5
-
-    const int32_t mask = (1 << shift);
-    int32_t col = 0;
-    const int8_t *in_ptr = input_data;
-    int8_t *out_ptr = output_data;
-
-    for (int row_idx = 0; row_idx < height; row_idx++) {
-        int8_t max_in_row = in_ptr[0];
-        for (col = 1; col < width; col++) {
-            max_in_row = max(max_in_row, in_ptr[col]);
-        }
-
-        int32_t input_diff = 0;
-        int32_t sum_of_exps = 0;
-
-        for (col = 0; col < width; col++) {
-            input_diff = in_ptr[col] - max_in_row;
-            if (input_diff >= diff_min) {
-                const int32_t input_diff_rescaled = SAT_HIGH_MUL(input_diff * mask, mult);
-                const int32_t exp_raw = esp_nn_exp_on_negative_values(input_diff_rescaled);
-                sum_of_exps += DIV_POW2(exp_raw, ACCUM_BITS);
-            }
-        }
-
-        const int32_t headroom_plus1 = esp_nn_clz32((uint32_t) sum_of_exps);
-        const int32_t shifted_scale = ONE_OVER_ONE_X((sum_of_exps << headroom_plus1) - (1 << 31));
-        const int32_t bits_over_unit = ACCUM_BITS - headroom_plus1 + 31 - sizeof(int8_t) * 8;
-
-        for (col = 0; col < width; col++) {
-            input_diff = in_ptr[col] - max_in_row;
-            if (input_diff >= diff_min) {
-                const int32_t input_diff_rescaled = SAT_HIGH_MUL(input_diff * mask, mult);
-                const int32_t exp_raw = esp_nn_exp_on_negative_values(input_diff_rescaled);
-                const int32_t shifted_output = SAT_HIGH_MUL(shifted_scale, exp_raw);
-                const int32_t result = DIV_POW2(shifted_output, bits_over_unit) - 128;
-                out_ptr[col] = (int8_t) esp_nn_saturate8(result);
-            } else {
-                out_ptr[col] = -128;
-            }
-        }
-        in_ptr  += width;
-        out_ptr += width;
-    }
-}

code/components/esp-nn/src/softmax/esp_nn_softmax_opt.c

@@ -1,108 +0,0 @@
-// Copyright 2022 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 "softmax_common.h"
-#include <stdio.h>
-
-static int32_t *scratch_buf = NULL;
-
-/**
- * @brief   Get scratch buffer size needed by softmax function
- *
- * @param   width
- * @param   height
- * @return  size in bytes
- *
- * @note    buffer must be 4 byte aligned
- */
-int32_t esp_nn_get_softmax_scratch_size_opt(const int32_t width, const int32_t height)
-{
-    (void) height;
-    return width * 4;
-}
-
-/**
- * @brief   Set scratch buffer to be used by softmax function
- *
- * @param   buffer  this can be NULL if one needs to unset it
- *                  must be aligned to 4 bytes
- */
-void esp_nn_set_softmax_scratch_buf_opt(void *buffer)
-{
-    scratch_buf = (int32_t *) buffer;
-}
-
-void esp_nn_softmax_s8_opt(const int8_t *input_data,
-                           const int32_t height,
-                           const int32_t width,
-                           const int32_t mult,
-                           const int32_t shift,
-                           const int32_t diff_min,
-                           int8_t *output_data)
-{
-    if (scratch_buf == NULL) {
-        printf("%s error! scratch buffer not set\n", __FUNCTION__);
-        return;
-    }
-    // The representation chosen for the input to the exp() function is Q5.26.
-    // We need to leave extra space since values that we skip might be as large as
-    // -32 before multiplying by input mult, and therefore as large as
-    // -16 afterwards.  Note that exp(-8) is definitely not insignificant to
-    // accumulation, but exp(-16) definitely is.
-#define ACCUM_BITS  12
-#define DIFF_BITS   5
-
-    const int32_t mask = (1 << shift);
-    int32_t col = 0;
-    const int8_t *in_ptr = input_data;
-    int8_t *out_ptr = output_data;
-
-    for (int row_idx = 0; row_idx < height; row_idx++) {
-        int8_t max_in_row = in_ptr[0];
-        for (col = 1; col < width; col++) {
-            max_in_row = max(max_in_row, in_ptr[col]);
-        }
-
-        int32_t input_diff = 0;
-        int32_t sum_of_exps = 0;
-
-        for (col = 0; col < width; col++) {
-            input_diff = in_ptr[col] - max_in_row;
-            if (input_diff >= diff_min) {
-                const int32_t input_diff_rescaled = SAT_HIGH_MUL(input_diff * mask, mult);
-                const int32_t exp_raw = esp_nn_exp_on_negative_values(input_diff_rescaled);
-                scratch_buf[col] = exp_raw; // store to avoid duplicate calculation later
-                sum_of_exps += DIV_POW2(exp_raw, ACCUM_BITS);
-            }
-        }
-
-        const int32_t headroom_plus1 = esp_nn_clz32((uint32_t) sum_of_exps);
-        const int32_t shifted_scale = ONE_OVER_ONE_X((sum_of_exps << headroom_plus1) - (1 << 31));
-        const int32_t bits_over_unit = ACCUM_BITS - headroom_plus1 + 31 - sizeof(int8_t) * 8;
-
-        for (col = 0; col < width; col++) {
-            input_diff = in_ptr[col] - max_in_row;
-            if (input_diff >= diff_min) {
-                int32_t exp_raw = scratch_buf[col];
-                const int32_t shifted_output = SAT_HIGH_MUL(shifted_scale, exp_raw);
-                const int32_t result = DIV_POW2(shifted_output, bits_over_unit) - 128;
-                out_ptr[col] = (int8_t) esp_nn_saturate8(result);
-            } else {
-                out_ptr[col] = -128;
-            }
-        }
-        in_ptr  += width;
-        out_ptr += width;
-    }
-}

code/components/esp-nn/src/softmax/softmax_common.h

@@ -1,104 +0,0 @@
-// Copyright 2022 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 <stdint.h>
-#include <common_functions.h>
-
-#define MASK_IF_ZERO(x)                 (x) == 0 ? ~0 : 0
-#define MASK_IF_NON_ZERO(x)             (x) != 0 ? ~0 : 0
-#define SELECT_USING_MASK(mask, a, b)   ((mask) & (a)) ^ (~(mask) & (b))
-#define SAT_HIGH_MUL(x, y)              esp_nn_sat_round_doubling_high_mul((x), (y))
-#define DIV_POW2(x,y)                   esp_nn_div_by_power_of_two((x), (y))
-
-__NN_FORCE_INLINE__ int32_t mul_power_of_2(int val, int exp)
-{
-    const int32_t thresh = ((1 << (31 - exp)) - 1);
-    int32_t result = val << exp;
-    result = SELECT_USING_MASK(MASK_IF_NON_ZERO(val > thresh), INT32_MAX, result);
-    result = SELECT_USING_MASK(MASK_IF_NON_ZERO(val < -thresh), INT32_MIN, result);
-    return result;
-}
-
-/**
- * @brief   Calculate `1 / (1 + x)` for x in [0, 1]
- *
- * @param   val     input value to calculate `1/(1+x)` for
- * @return  `int32_t` result
- * @note    Newton-Raphson division
- *
- *          https://en.wikipedia.org/wiki/Division_algorithm#Newton.E2.80.93Raphson_division
- *          Refer to that page for the logic behind the 48/17 and 32/17 constants.
- *          Pseudocode: https://en.wikipedia.org/wiki/Division_algorithm#Pseudocode
- */
-__NN_FORCE_INLINE__ int32_t esp_nn_one_over_one_plus_x_for_x_in_0_1(int32_t val)
-{
-    const int64_t sum = (int64_t) val + INT32_MAX;
-    const int32_t half_denominator = (int32_t) ((sum + (sum >= 0 ? 1 : -1)) / 2L);
-    int32_t constant_48_over_17 = 1515870810;
-    int32_t constant_neg_32_over_17 = -1010580540;
-    int32_t x = constant_48_over_17 + SAT_HIGH_MUL(half_denominator, constant_neg_32_over_17);
-    const int32_t fixed_2_one = (1 << 29);
-
-    x += mul_power_of_2(SAT_HIGH_MUL(x, fixed_2_one - SAT_HIGH_MUL(half_denominator, x)), 2);
-    x += mul_power_of_2(SAT_HIGH_MUL(x, fixed_2_one - SAT_HIGH_MUL(half_denominator, x)), 2);
-    x += mul_power_of_2(SAT_HIGH_MUL(x, fixed_2_one - SAT_HIGH_MUL(half_denominator, x)), 2);
-
-    return mul_power_of_2(x, 1);
-}
-
-#define ONE_OVER_ONE_X(x)   esp_nn_one_over_one_plus_x_for_x_in_0_1((x))
-
-/**
- * @brief   Return exp(x) for x < 0.
- *
- */
-__NN_FORCE_INLINE__ int32_t esp_nn_exp_on_negative_values(int32_t val)
-{
-    int32_t shift = 24;
-
-    const int32_t one_quarter = (1 << shift);
-    int32_t mask = one_quarter - 1;
-    const int32_t val_mod_minus_quarter = (val & mask) - one_quarter;
-    const int32_t remainder             = val_mod_minus_quarter - val;
-
-    // calculate exponent for x in [-1/4, 0) in `result`
-    const int32_t x                     = (val_mod_minus_quarter << 5) + (1 << 28);
-    const int32_t x2                    = SAT_HIGH_MUL(x, x);
-    const int32_t x3                    = SAT_HIGH_MUL(x2, x);
-    const int32_t x4                    = SAT_HIGH_MUL(x2, x2);
-    const int32_t one_over_3            = 715827883;
-    const int32_t one_over_8            = 1895147668;
-
-    const int32_t x4_over_4 = DIV_POW2(x4, 2);
-    const int32_t x4_over_4_plus_x3_over_6_plus_x2_over_2 = DIV_POW2(SAT_HIGH_MUL(x4_over_4 + x3, one_over_3) + x2, 1);
-    int32_t result = one_over_8 + SAT_HIGH_MUL(one_over_8, x + x4_over_4_plus_x3_over_6_plus_x2_over_2);
-
-#define SELECT_IF_NON_ZERO(x) {                                   \
-    mask   = MASK_IF_NON_ZERO(remainder & (1 << shift++));        \
-    result = SELECT_USING_MASK(mask, SAT_HIGH_MUL(result, x), result); \
-}
-
-    SELECT_IF_NON_ZERO(1672461947)
-    SELECT_IF_NON_ZERO(1302514674)
-    SELECT_IF_NON_ZERO(790015084)
-    SELECT_IF_NON_ZERO(290630308)
-    SELECT_IF_NON_ZERO(39332535)
-    SELECT_IF_NON_ZERO(720401)
-    SELECT_IF_NON_ZERO(242)
-
-#undef SELECT_IF_NON_ZERO
-
-    mask = MASK_IF_ZERO(val);
-    return SELECT_USING_MASK(mask, INT32_MAX, result);
-}

code/components/esp-nn/test_app/CMakeLists.txt

@@ -1,9 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-set(EXTRA_COMPONENT_DIRS "../" "../tests/")
-set(IDF_EXCLUDE_COMPONENTS test test_app)
-
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(test_app)

code/components/esp-nn/test_app/main/CMakeLists.txt

@@ -1,7 +0,0 @@
-
-set(COMPONENT_SRCS "main.c")
-set(COMPONENT_ADD_INCLUDEDIRS "")
-
-set(COMPONENT_PRIV_REQUIRES tests)
-
-register_component()

code/components/esp-nn/test_app/main/component.mk

@@ -1,8 +0,0 @@
-#
-# Main component makefile.
-#
-# This Makefile can be left empty. By default, it will take the sources in the 
-# src/ directory, compile them and link them into lib(subdirectory_name).a
-# in the build directory. This behaviour is entirely configurable,
-# please read the ESP-IDF documents if you need to do this.
-# 

code/components/esp-nn/test_app/main/main.c

@@ -1,87 +0,0 @@
-// Copyright 2020-2021 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 <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#include <esp_log.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <test_functions.h>
-#include <esp_timer.h>
-
-static const char *TAG = "test_app";
-static uint32_t start_c, start_opt, total_c, total_opt;
-
-void profile_c_start()
-{
-    /* initiate profiling */
-    start_c = esp_cpu_get_ccount();
-}
-
-void profile_c_end()
-{
-    /* record profile number */
-    total_c = esp_cpu_get_ccount() - start_c;
-}
-
-void profile_opt_start()
-{
-    /* initiate profiling */
-    start_opt = esp_cpu_get_ccount();
-}
-
-void profile_opt_end()
-{
-    /* record profile number */
-    total_opt = esp_cpu_get_ccount() - start_opt;
-}
-
-void app_main()
-{
-    /* s8 tests */
-    ESP_LOGI(TAG, "Running s8 tests...");
-    esp_nn_add_elementwise_s8_test();
-    printf("add, c %u opt %u\n", total_c, total_opt);
-    esp_nn_mul_elementwise_s8_test();
-    printf("mul, c %u opt %u\n", total_c, total_opt);
-    esp_nn_depthwise_conv_s8_test();
-    printf("depthwise, c %u opt %u\n", total_c, total_opt);
-    esp_nn_conv_s8_test();
-    printf("conv2d, c %u opt %u\n", total_c, total_opt);
-
-    esp_nn_relu6_s8_test();
-    printf("relu, c %u opt %u\n", total_c, total_opt);
-    esp_nn_avg_pool_s8_test();
-    printf("avg_pool, c %u opt %u\n", total_c, total_opt);
-    esp_nn_max_pool_s8_test();
-    printf("max_pool, c %u opt %u\n", total_c, total_opt);
-    esp_nn_fully_connected_s8_test();
-    printf("fully_connected, c %u opt %u\n", total_c, total_opt);
-    esp_nn_softmax_s8_test();
-    printf("softmax, c %u opt %u\n", total_c, total_opt);
-    ESP_LOGI(TAG, "s8 tests done!\n");
-
-    /* u8 tests */
-    //ESP_LOGI(TAG, "Running u8 tests...");
-    //esp_nn_add_elementwise_u8_test();
-    //esp_nn_depthwise_conv_u8_test();
-    //esp_nn_conv_u8_test();
-    //esp_nn_avg_pool_u8_test();
-    //esp_nn_max_pool_u8_test();
-    //esp_nn_fully_connected_u8_test();
-    //ESP_LOGI(TAG, "u8 tests done!\n");
-}

code/components/esp-nn/test_app/sdkconfig.defaults

@@ -1,5 +0,0 @@
-
-#
-# esp-nn
-#
-CONFIG_NN_ESP32=y

code/components/esp-nn/tests/CMakeLists.txt

@@ -1,15 +0,0 @@
-
-set(COMPONENT_ADD_INCLUDEDIRS ./include/)
-set(COMPONENT_SRCS "src/basic_math_test.c"
-                   "src/convolution_test.c"
-                   "src/fully_connected_test.c"
-                   "src/pooling_test.c"
-                   "src/relu_test.c"
-                   "src/softmax_test.c")
-
-set(COMPONENT_REQUIRES )
-set(COMPONENT_PRIV_REQUIRES esp-nn)
-
-register_component()
-
-target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-unused-function)

code/components/esp-nn/tests/README.md

@@ -1,4 +0,0 @@
-# Tests for esp_nn library
-
-- Include these in your test framework and run the framework.
-- For IDF test please refer `test_app`

code/components/esp-nn/tests/component.mk

@@ -1,5 +0,0 @@
-#FIXME
-
-COMPONENT_ADD_INCLUDEDIRS := include/
-
-COMPONENT_SRCDIRS :=  src/

code/components/esp-nn/tests/include/test_functions.h

@@ -1,48 +0,0 @@
-// Copyright 2020-2021 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.
-
-
-/* int8_t ops tests */
-void esp_nn_add_elementwise_s8_test();
-void esp_nn_mul_elementwise_s8_test();
-
-void esp_nn_depthwise_conv_s8_test();
-void esp_nn_conv_s8_test();
-
-void esp_nn_avg_pool_s8_test();
-void esp_nn_max_pool_s8_test();
-
-void esp_nn_fully_connected_s8_test();
-
-void esp_nn_relu6_s8_test();
-
-void esp_nn_softmax_s8_test();
-
-/* uint8_t ops tests */
-void esp_nn_add_elementwise_u8_test();
-
-void esp_nn_depthwise_conv_u8_test();
-void esp_nn_conv_u8_test();
-
-void esp_nn_avg_pool_u8_test();
-void esp_nn_max_pool_u8_test();
-
-void esp_nn_fully_connected_u8_test();
-
-/* instructions test functions */
-void compare_instructions_test();
-void arith_instructions_test();
-void min_max_instructions_test();
-void bitwise_instructions_test();
-void load_store_instructions_test();

code/components/esp-nn/tests/include/test_utils.h

@@ -1,87 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <common_functions.h>
-#include <stdio.h>
-
-/* mult value range */
-#define MULT_MAX    INT32_MAX
-#define MULT_MIN    0
-
-/* shift value range */
-#define SHIFT_MIN   -31
-#define SHIFT_MAX   30
-
-/**
- * @brief callback function to run before C function
- */
-void profile_c_start();
-
-/**
- * @brief callback function to run after C function
- */
-void profile_c_end();
-
-/**
- * @brief callback function to run before optimized function
- */
-void profile_opt_start();
-
-/**
- * @brief callback function to run after optimized function
- */
-void profile_opt_end();
-
-#define ANSI_COLOR_RED     "\x1b[31m"
-#define ANSI_COLOR_GREEN   "\x1b[32m"
-#define ANSI_COLOR_YELLOW  "\x1b[33m"
-#define ANSI_COLOR_BLUE    "\x1b[34m"
-#define ANSI_COLOR_MAGENTA "\x1b[35m"
-#define ANSI_COLOR_CYAN    "\x1b[36m"
-#define ANSI_COLOR_RESET   "\x1b[0m"
-
-#define CHECK_EQUAL(ARRAY1, ARRAY2, size) ({    \
-    bool res = true;                            \
-    for (int _i = 0; _i < size; _i++) {         \
-        if (ARRAY1[_i] != ARRAY2[_i]) {         \
-            res = false;                        \
-            break;                              \
-        }                                       \
-    }                                           \
-    res;                                        \
-})
-
-#define PRINT_ARRAY_INT(ARRAY, width, height) ({        \
-    int *_array = (int *) ARRAY;                        \
-    for (int _j = 0; _j < height; _j++) {               \
-        for (int _i = 0; _i < width; _i++) {            \
-            printf("%d\t", _array[width * _j + _i]);    \
-        }                                               \
-        printf("\n");                                   \
-    }                                                   \
-    printf("\n");                                       \
-})
-
-#define PRINT_ARRAY_HEX(ARRAY, width, height) ({        \
-    uint8_t *_array = (uint8_t *) ARRAY;                \
-    for (int _j = 0; _j < height; _j++) {               \
-        for (int _i = 0; _i < width; _i++) {            \
-            printf("%02x\t", _array[width * _j + _i]);  \
-        }                                               \
-        printf("\n");                                   \
-    }                                                   \
-    printf("\n");                                       \
-})

code/components/esp-nn/tests/src/basic_math_test.c

@@ -1,343 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-
-#include <common_functions.h>
-#include <esp_nn.h>
-#include "test_utils.h"
-
-#if CONFIG_IDF_CMAKE
-#define IDF_HEAP_CAPS 1
-
-#if IDF_HEAP_CAPS
-#include "esp_heap_caps.h"
-#endif
-#endif
-
-void esp_nn_add_elementwise_s8_test()
-{
-    /* prepare data */
-    const int size = 1600 + 8 + 7; /* odd len to test leftover */
-    int8_t *input1;
-    int8_t *input2;
-    int8_t *out_data_c;
-    int8_t *out_data_opt;
-    int8_t *input1_orig = NULL;
-    int8_t *input2_orig = NULL;
-    int8_t *out_c_orig = NULL;
-    int8_t *out_opt_orig = NULL;
-    int32_t input1_offset = 34;
-    int32_t input2_offset = 35;
-    int32_t output_offset = 36;
-    int32_t input1_shift = -8; // right_shift amt always <= 0
-    int32_t input2_shift = -8; // right_shift amt always <= 0
-    int32_t output_shift = -9; // right_shift amt always <= 0
-    int32_t left_shift = 15; // always +ve
-    int32_t input1_mult = INT32_MAX;
-    int32_t input2_mult = INT32_MAX;
-    int32_t output_mult = INT32_MAX;
-    int32_t activation_min = -128;
-    int32_t activation_max = 127;
-
-    for (int itr = 0; itr < 10; itr++) {
-        switch (itr) {
-        case 0: // all zeros
-            input1_offset = 0;
-            input2_offset = 0;
-            output_offset = 0;
-            input1_mult = 0;
-            input2_mult = 0;
-            output_mult = 0;
-            input1_shift = 0;
-            input2_shift = 0;
-            output_shift = 0;
-            left_shift = 0;
-        break;
-        case 1: // hit min
-            input1_offset = -127;
-            input2_offset = -127;
-            output_offset = -128;
-            input1_mult = MULT_MIN;
-            input2_mult = MULT_MIN;
-            output_mult = MULT_MIN;
-            input1_shift = 0;
-            input2_shift = 0;
-            output_shift = 0;
-            left_shift = 0;
-        break;
-        case 2: // hit max
-            input1_offset = 128;
-            input2_offset = 128;
-            output_offset = -127;
-            input1_mult = MULT_MAX;
-            input2_mult = MULT_MAX;
-            output_mult = MULT_MAX;
-            input1_shift = SHIFT_MIN;
-            input2_shift = SHIFT_MIN;
-            output_shift = SHIFT_MIN;
-            left_shift = 30 - 8; // since input is 8 bits
-        break;
-        case 3: // hit extreme max
-            input1_offset = 128;
-            input2_offset = 128;
-            output_offset = -127;
-            input1_mult = MULT_MAX;
-            input2_mult = MULT_MAX;
-            output_mult = MULT_MAX;
-            input1_shift = 0;
-            input2_shift = 0;
-            output_shift = 0;
-            left_shift = 30 - 8; // -8 since input is 8 bit
-        break;
-        default:  // practical random input
-            input1_offset = rand() % 256 - 127; // range [-127, 128]
-            input2_offset = rand() % 256 - 127; // range [-127, 128]
-            output_offset = rand() % 256 - 128; // range [-128, 127]
-            input1_mult = MULT_MAX / 2 + rand() % INT16_MAX;
-            input2_mult = MULT_MAX / 2 + rand() % INT16_MAX;
-            output_mult = MULT_MAX / 2 + rand() % INT16_MAX;
-            input1_shift = -8 + rand() % 4;
-            input2_shift = -8 + rand() % 4;
-            output_shift = -8 + rand() % 4;
-            left_shift = rand() % 15;
-        }
-#if IDF_HEAP_CAPS
-        input1_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        input2_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_c_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_opt_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-
-        input1 = 16 + input1_orig - ((uint32_t) input1_orig & 0xf);
-        input2 = 16 + input2_orig - ((uint32_t) input2_orig & 0xf);
-        out_data_c = 16 + out_c_orig - ((uint32_t) out_c_orig & 0xf);
-        out_data_opt = 16 + out_opt_orig - ((uint32_t) out_opt_orig & 0xf);
-#else
-        input1 = memalign(16, size);
-        input2 = memalign(16, size);
-        out_data_c = memalign(16, size);
-        out_data_opt = memalign(16, size);
-
-        input1_orig = input1;
-        input2_orig = input2;
-        out_c_orig = out_data_c;
-        out_opt_orig = out_data_opt;
-#endif
-
-        for (int i = 0; i < size; ++i) {
-            input1[i] = rand() % 256 - 128;
-            input2[i] = rand() % 256 - 128;
-        }
-
-        if (itr == 0) {
-            /* enable profiler */
-            profile_c_start();
-        }
-        /* C function */
-        esp_nn_add_elementwise_s8_ansi(input1, input2, input1_offset, input2_offset,
-                                       input1_mult, input2_mult, input1_shift, input2_shift,
-                                       left_shift, out_data_c, output_offset, output_mult,
-                                       output_shift, activation_min, activation_max, size);
-
-        if (itr == 0) {
-            profile_c_end();
-            profile_opt_start();
-        }
-
-        /* Optimized function */
-        esp_nn_add_elementwise_s8(input1, input2, input1_offset, input2_offset,
-                                  input1_mult, input2_mult, input1_shift, input2_shift,
-                                  left_shift, out_data_opt, output_offset, output_mult,
-                                  output_shift, activation_min, activation_max, size);
-        if (itr == 0) {
-            /* disable profiler */
-            profile_opt_end();
-        }
-
-        bool ret = CHECK_EQUAL(out_data_c, out_data_opt, size);
-        if (ret == false) {
-            printf(ANSI_COLOR_RED"%s[%d] failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            printf("Output: \n");
-            PRINT_ARRAY_HEX(out_data_opt, size, 1);
-            printf("Expected: \n");
-            PRINT_ARRAY_HEX(out_data_c, size, 1);
-            printf("Input1:\n");
-            PRINT_ARRAY_HEX(input1, size, 1);
-            printf("Input2:\n");
-            PRINT_ARRAY_HEX(input2, size, 1);
-            printf("in1_shift %d, in2_shift %d, left_shift %d, out_shift %d\n",
-                   input1_shift, input2_shift, left_shift, output_shift);
-            printf("in1_mult %d, in2_mult %d, out_mult %d\n", input1_mult, input2_mult, output_mult);
-            goto elementwise_add_test_cleanup;
-        }
-        printf(ANSI_COLOR_GREEN"%s[%d] passed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-
-elementwise_add_test_cleanup:
-        if (input1_orig) {
-            free(input1_orig);
-        }
-        if (input2_orig) {
-            free(input2_orig);
-        }
-        if (out_data_c) {
-            free(out_c_orig);
-        }
-        if (out_data_opt) {
-            free(out_opt_orig);
-        }
-    }
-}
-
-void esp_nn_mul_elementwise_s8_test()
-{
-    /* prepare data */
-    const int size = 1600 + 8 + 7; /* odd len to test leftover */
-    int8_t *input1;
-    int8_t *input2;
-    int8_t *out_data_c;
-    int8_t *out_data_opt;
-    int32_t input1_offset = 34;
-    int32_t input2_offset = 35;
-    int32_t output_offset = 36;
-    int32_t output_shift = -7;
-    int32_t output_mult = MULT_MAX; // max out_mult
-    int32_t activation_min = -128;
-    int32_t activation_max = 127;
-    int8_t *input1_orig = NULL;
-    int8_t *input2_orig = NULL;
-    int8_t *out_c_orig = NULL;
-    int8_t *out_opt_orig = NULL;
-
-    for (int itr = 0; itr < 10; itr++) {
-        switch (itr) {
-        case 0: // all zeros
-            input1_offset = 0;
-            input2_offset = 0;
-            output_offset = 0;
-            output_mult = 0;
-            output_shift = 0;
-        break;
-        case 1: // hit min
-            input1_offset = -127;
-            input2_offset = -127;
-            output_offset = -128;
-            output_mult = MULT_MIN;
-            output_shift = 0;
-        break;
-        case 2: // hit max
-            input1_offset = 128;
-            input2_offset = 128;
-            output_offset = -127;
-            output_mult = MULT_MAX;
-            output_shift = SHIFT_MIN;
-        break;
-        case 3: // hit extreme max
-            input1_offset = 128;
-            input2_offset = 128;
-            output_offset = -127;
-            output_mult = MULT_MAX;
-            output_shift = 0;
-        break;
-        default:  // practical random input
-            input1_offset = rand() % 256 - 127; // range [-127, 128]
-            input2_offset = rand() % 256 - 127; // range [-127, 128]
-            output_offset = rand() % 256 - 128; // range [-128, 127]
-            output_mult = MULT_MAX / 2 + rand() % INT16_MAX;
-            output_shift = -8 + rand() % 4;
-        }
-
-#if IDF_HEAP_CAPS
-        input1_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        input2_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_c_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_opt_orig = (int8_t *) heap_caps_malloc(size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-
-        input1 = 16 + input1_orig - ((uint32_t) input1_orig & 0xf);
-        input2 = 16 + input2_orig - ((uint32_t) input2_orig & 0xf);
-        out_data_c = 16 + out_c_orig - ((uint32_t) out_c_orig & 0xf);
-        out_data_opt = 16 + out_opt_orig - ((uint32_t) out_opt_orig & 0xf);
-#else
-        input1 = memalign(16, size);
-        input2 = memalign(16, size);
-        out_data_c = memalign(16, size);
-        out_data_opt = memalign(16, size);
-
-        input1_orig = input1;
-        input2_orig = input2;
-        out_c_orig = out_data_c;
-        out_opt_orig = out_data_opt;
-#endif
-
-        for (int i = 0; i < size; ++i) {
-            input1[i] = rand() % 256 - 128;
-            input2[i] = rand() % 256 - 128;
-        }
-
-        if (itr == 0) {
-            /* enable profiler */
-            profile_c_start();
-        }
-        /* C function */
-        esp_nn_mul_elementwise_s8_ansi(input1, input2, input1_offset, input2_offset,
-                                       out_data_c, output_offset, output_mult, output_shift,
-                                       activation_min, activation_max, size);
-
-        if (itr == 0) {
-            profile_c_end();
-            profile_opt_start();
-        }
-        /* Optimized function */
-        esp_nn_mul_elementwise_s8(input1, input2, input1_offset, input2_offset,
-                                  out_data_opt, output_offset, output_mult, output_shift,
-                                  activation_min, activation_max, size);
-
-        if (itr == 0) {
-            /* disable profiler */
-            profile_opt_end();
-        }
-
-        bool ret = CHECK_EQUAL(out_data_c, out_data_opt, size);
-        if (ret == false) {
-            printf(ANSI_COLOR_RED"%s[%d] failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            printf("Output: \n");
-            PRINT_ARRAY_HEX(out_data_opt, size, 1);
-            printf("Expected: \n");
-            PRINT_ARRAY_HEX(out_data_c, size, 1);
-            printf("Input1:\n");
-            PRINT_ARRAY_HEX(input1, size, 1);
-            printf("Input2:\n");
-            PRINT_ARRAY_HEX(input2, size, 1);
-            goto elementwise_mult_test_cleanup;
-        }
-        printf(ANSI_COLOR_GREEN"%s[%d] passed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-
-elementwise_mult_test_cleanup:
-        if (input1_orig) {
-            free(input1_orig);
-        }
-        if (input2_orig) {
-            free(input2_orig);
-        }
-        if (out_data_c) {
-            free(out_c_orig);
-        }
-        if (out_data_opt) {
-            free(out_opt_orig);
-        }
-    }
-}

code/components/esp-nn/tests/src/convolution_test.c

@@ -1,571 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-
-#include <esp_nn.h>
-#include "test_utils.h"
-
-#if CONFIG_IDF_CMAKE
-#define IDF_HEAP_CAPS 1
-
-#if IDF_HEAP_CAPS
-#include "esp_heap_caps.h"
-#endif
-#endif
-
-void esp_nn_depthwise_conv_s8_test()
-{
-    int8_t *input = NULL, *filter_data = NULL, *out_data_c = NULL, *out_data_opt = NULL;
-    int32_t *bias = NULL;
-    int32_t input_offset = 5; /* some number in [-128, 127] */
-    int32_t out_offset = 7;
-    int32_t activation_min = -125;
-    int32_t activation_max = 120;
-    void *scratch_buf = NULL;
-
-    /* independent variables */
-    int input_wd, input_ht, channels;
-    uint16_t filter_ht, filter_wd, ch_mult;
-    uint16_t pad_wd, pad_ht, stride_wd, stride_ht;
-
-    // run for 10 iterations
-    for (int itr = 0; itr < 10; itr++) {
-        /* prepare data */
-        switch (itr) {
-        case 0: // (ch_mult 1, (channels % 16) = 0), filter (3,3), pad (0,0)
-            input_wd = 18;
-            input_ht = 18;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 1;
-            channels = 16;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 1: // (ch_mult 1, (channels % 16) = 0), filter (3,3), pad (1,1)
-            input_wd = 10;
-            input_ht = 10;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 1;
-            channels = 16;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 2: // (ch_mult 1, (channels % 8) = 0), filter (3,3), pad (1,1)
-            input_wd = 10;
-            input_ht = 10;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 1;
-            channels = 24;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 3: // other filter sizes (ch_mult 1, (channels % 8) = 0)
-            input_wd = 10;
-            input_ht = 10;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 1;
-            channels = 24;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 4: // other filter sizes (ch_mult 8 = 0)
-            input_wd = 6;
-            input_ht = 6;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 8;
-            channels = 4;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 5: // other filter sizes (ch_mult 8 = 0)
-            input_wd = 12;
-            input_ht = 12;
-            filter_ht = 5;
-            filter_wd = 5;
-            ch_mult = 8;
-            channels = 4;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 6: // other filter sizes (ch_mult 4 = 0)
-            input_wd = 6;
-            input_ht = 6;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 4;
-            channels = 4;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 7: // (ch_mult 1, (channels % 16) = 0), filter (3,3), pad (0,0)  stride (2,2)
-            input_wd = 6;
-            input_ht = 6;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 1;
-            channels = 16;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 2;
-            stride_ht = 2;
-            break;
-        default:
-            input_wd = 4;
-            input_ht = 4;
-            filter_ht = 3;
-            filter_wd = 3;
-            ch_mult = 4;
-            channels = 4;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        }
-
-        uint16_t out_wd = (input_wd - filter_wd + 1) / stride_wd;
-        uint16_t out_ht = (input_ht - filter_ht + 1) / stride_ht;
-        int in_size = input_wd * input_ht * channels;
-        int out_size = out_wd * out_ht * channels * ch_mult;
-        int filter_size = filter_wd * filter_ht * channels * ch_mult + 4;
-        int bias_size = channels * ch_mult + 1;
-        int32_t out_shift[channels * ch_mult];
-        int32_t out_mult[channels * ch_mult];
-
-#if IDF_HEAP_CAPS
-        int8_t *input_orig = (int8_t *) heap_caps_malloc(in_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        int8_t *out_c_orig = (int8_t *) heap_caps_malloc(out_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        int8_t *out_opt_orig = (int8_t *) heap_caps_malloc(out_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        filter_data = (int8_t *) heap_caps_malloc(filter_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        bias = (int32_t *) heap_caps_malloc(bias_size * 4, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-
-        input = 16 + input_orig - ((uint32_t) input_orig & 0xf);
-        out_data_c = 16 + out_c_orig - ((uint32_t) out_c_orig & 0xf);
-        out_data_opt = 16 + out_opt_orig - ((uint32_t) out_opt_orig & 0xf);
-#else
-        input = memalign(16, in_size + 16);
-        filter_data = memalign(16, filter_size);
-        out_data_c = memalign(16, out_size + 16);
-        out_data_opt = memalign(16, out_size + 16);
-        bias = memalign(16, bias_size * 4);
-        int8_t *input_orig = input;
-        int8_t *out_c_orig = out_data_c;
-        int8_t *out_opt_orig = out_data_opt;
-#endif
-        if (bias == NULL || input == NULL || filter_data == NULL ||
-                out_data_c == NULL || out_data_opt == NULL || bias == NULL) {
-            printf(ANSI_COLOR_RED"%s[%d] allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            goto dc_s8_cleanup;
-        }
-
-        /* Generate input data */
-        for (int i = 0; i < in_size; ++i) {
-            input[i] = rand() % 128;
-        }
-
-        /* Generate filter data */
-        for (int i = 0; i < filter_size; ++i) {
-            filter_data[i] = rand() % 256 - 128;
-        }
-
-        /* Generate bias data */
-        for (int i = 0; i < channels * ch_mult; ++i) {
-            bias[i + 1] = rand() % INT16_MAX; //0th index left for unalignment
-            out_shift[i] = -8 + rand() % 3;
-            out_mult[i] = 0x7eb0e200 + rand() % 50;
-        }
-
-        int scratch_buf_size = esp_nn_get_depthwise_conv_scratch_size(input_wd, input_ht,
-                                                                    channels, ch_mult,
-                                                                    filter_wd, filter_ht);
-        if (scratch_buf_size > 0) {
-#if IDF_HEAP_CAPS
-            scratch_buf = heap_caps_malloc(scratch_buf_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-            int align_sz = 16 - (((int32_t) scratch_buf) & 0xf);
-#else
-            scratch_buf = memalign(16, scratch_buf_size);
-            int align_sz = 0;
-#endif
-            if (scratch_buf == NULL) {
-                printf(ANSI_COLOR_RED"%s[%d] scratch_buf alloc failed size %d\n"ANSI_COLOR_RESET,
-                       __FUNCTION__, itr, scratch_buf_size);
-                goto dc_s8_cleanup;
-            }
-            esp_nn_set_depthwise_conv_scratch_buf(scratch_buf + align_sz);
-        }
-        if (itr == 0) {
-            /* enable profiler */
-            profile_c_start();
-        }
-
-        /* C function */
-        esp_nn_depthwise_conv_s8_ansi(input, input_wd, input_ht, channels, input_offset,
-                                    pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                    filter_data + 4, filter_wd, filter_ht,
-                                    bias + 1, out_data_c, out_wd, out_ht, out_offset, out_shift,
-                                    out_mult, activation_min, activation_max);
-
-        if (itr == 0) {
-            profile_c_end();
-            profile_opt_start();
-        }
-
-        /* Optimized function */
-        esp_nn_depthwise_conv_s8(input, input_wd, input_ht, channels, input_offset,
-                                pad_wd, pad_ht, stride_wd, stride_ht, ch_mult,
-                                filter_data + 4, filter_wd, filter_ht,
-                                bias + 1, out_data_opt, out_wd, out_ht, out_offset, out_shift,
-                                out_mult, activation_min, activation_max);
-
-        if (itr == 0) {
-            /* disable profiler */
-            profile_opt_end();
-        }
-
-        bool ret = CHECK_EQUAL(out_data_c, out_data_opt, out_size);
-        if (ret == false) {
-            printf(ANSI_COLOR_RED"%s[%d] failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            printf("Output: \n");
-            PRINT_ARRAY_HEX(out_data_opt, out_size / out_ht, out_ht);
-            printf("Expected: \n");
-            PRINT_ARRAY_HEX(out_data_c, out_size / out_ht, out_ht);
-            printf("Input:\n");
-            PRINT_ARRAY_HEX(input, in_size / input_ht, input_ht);
-            printf("Filter data:\n");
-            PRINT_ARRAY_HEX(filter_data + 4, (filter_size - 4) / filter_ht, filter_ht);
-            printf("bias data:\n");
-            PRINT_ARRAY_INT(bias + 1, ch_mult * channels, 1);
-            goto dc_s8_cleanup;
-        }
-        printf(ANSI_COLOR_GREEN"%s[%d] passed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-
-    dc_s8_cleanup:
-        if (input) {
-            free(input_orig);
-        }
-        if (filter_data) {
-            free(filter_data);
-        }
-        if (out_data_c) {
-            free(out_c_orig);
-        }
-        if (out_data_opt) {
-            free(out_opt_orig);
-        }
-        if (bias) {
-            free(bias);
-        }
-        if (scratch_buf) {
-            free(scratch_buf);
-        }
-    }
-}
-
-void esp_nn_conv_s8_test()
-{
-    const int32_t input_offset = 5; /* some number in [-128, 127] */
-    const int32_t activation_min = -125;
-    const int32_t activation_max = 122;
-    const int32_t out_offset = 3;
-
-    void *scratch_buf = NULL;
-    int8_t *input_orig;
-    int8_t *out_c_orig;
-    int8_t *out_opt_orig;
-    int8_t *filter_data;
-    int32_t *bias;
-
-    /* independent variable */
-    int in_wd, in_ht, in_channels, out_channels;
-    uint16_t filter_ht, filter_wd;
-    uint16_t pad_wd, pad_ht, stride_wd, stride_ht;
-
-    // run for 10 iterations
-    for (int itr = 0; itr < 10; itr++) {
-        switch (itr) {
-        case 0: // ch % 8 == 0 && filter (1,1), padding (0,0)
-            in_wd = 10;
-            in_ht = 10;
-            in_channels = 64;
-            out_channels = 64;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 1: // ch % 4 == 0 && (in_wd * in_ht) % 16 == 0
-            in_wd = 4;
-            in_ht = 4;
-            in_channels = 20;
-            out_channels = 8;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 2: // ch, filter (3x3x3)
-            in_wd = 10;
-            in_ht = 10;
-            in_channels = 3;
-            out_channels = 64;
-            filter_ht = 3;
-            filter_wd = 3;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 3: // remaining pad (0, 0)
-            in_wd = 10;
-            in_ht = 10;
-            in_channels = 3;
-            out_channels = 64;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 4: // unopt case
-            in_wd = 10;
-            in_ht = 10;
-            in_channels = 12;
-            out_channels = 64;
-            filter_ht = 3;
-            filter_wd = 3;
-            pad_wd = 1;
-            pad_ht = 1;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        case 5: // ch % 8 == 0 & stride (2,2)
-            in_wd = 16;
-            in_ht = 16;
-            in_channels = 16;
-            out_channels = 16;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 2;
-            stride_ht = 2;
-            break;
-        case 6: // ch % 8 == 0 && filter (1,1), padding (0,0)
-            in_wd = 2;
-            in_ht = 2;
-            in_channels = 8;
-            out_channels = 8;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        default: // ch % 8 == 0
-            in_wd = 8;
-            in_ht = 8;
-            in_channels = 16;
-            out_channels = 16;
-            filter_ht = 1;
-            filter_wd = 1;
-            pad_wd = 0;
-            pad_ht = 0;
-            stride_wd = 1;
-            stride_ht = 1;
-            break;
-        }
-
-        /* prepare data */
-        uint16_t out_wd = (in_wd - filter_wd + 1) / stride_wd;
-        uint16_t out_ht = (in_ht - filter_ht + 1) / stride_ht;
-
-        int in_size = in_wd * in_ht * in_channels;
-        int filter_size = filter_wd * filter_ht * in_channels * out_channels + 2;
-        int out_size = out_wd * out_ht * out_channels;
-
-#if IDF_HEAP_CAPS
-        input_orig = (int8_t *) heap_caps_malloc(in_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_c_orig = (int8_t *) heap_caps_malloc(out_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        out_opt_orig = (int8_t *) heap_caps_malloc(out_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        filter_data = (int8_t *) heap_caps_malloc(filter_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-        bias = (int32_t *) heap_caps_malloc(128 + sizeof (int32_t) * out_channels, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-
-        int8_t *input = 16 + input_orig - ((uint32_t) input_orig & 0xf);
-        int8_t *out_data_c = 16 + out_c_orig - ((uint32_t) out_c_orig & 0xf);
-        int8_t *out_data_opt = 16 + out_opt_orig - ((uint32_t) out_opt_orig & 0xf);
-#else
-        int8_t *input = memalign(16, in_size);
-        int8_t *out_data_c = memalign(16, out_size);
-        int8_t *out_data_opt = memalign(16, out_size);
-        filter_data = memalign(16, filter_size);
-        bias = calloc(1, 128 + sizeof (int32_t) * out_channels);
-        input_orig = input;
-        out_c_orig = out_data_c;
-        out_opt_orig = out_data_opt;
-#endif
-        int32_t *out_shift = calloc(1, 128 + sizeof (int32_t) * out_channels);
-        int32_t *out_mult = calloc(1, 128 + sizeof (int32_t) * out_channels);
-
-        if (input == NULL || filter_data == NULL ||
-                out_data_c == NULL || out_data_opt == NULL) {
-            printf(ANSI_COLOR_RED"%s allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-            goto conv_s8_cleanup;
-        }
-
-        if (bias == NULL || out_shift == NULL || out_mult == NULL) {
-            printf(ANSI_COLOR_RED"%s allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-            goto conv_s8_cleanup;
-        }
-
-        /* Generate input data between -128 -> +127 */
-        for (int i = 0; i < in_size; ++i) {
-            input[i] = rand() % 255 - 128;
-        }
-
-        /* Generate filter data between -128 -> +127 */
-        for (int i = 0; i < filter_size; ++i) {
-            filter_data[i] = rand() % 256 - 128;
-        }
-
-        /* Generate bias data */
-        for (int i = 0; i < out_channels; ++i) {
-            bias[i] = (int32_t)rand() % UINT16_MAX + UINT8_MAX;
-        }
-
-        /* Shift and multiplier */
-        for (int i = 0; i < out_channels; ++i) {
-            out_shift[i] = -10 + rand() % 2;
-            out_mult[i] = 0x7f67f4f8 + rand() % 50;
-        }
-
-        int scratch_buf_size = esp_nn_get_conv_scratch_size(in_wd, in_ht, in_channels,
-                                                            out_channels, filter_wd, filter_ht);
-        if (scratch_buf_size > 0) {
-#if IDF_HEAP_CAPS
-            void *scratch_buf = heap_caps_malloc(scratch_buf_size + 32, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-            int align_sz = 16 - (((int32_t) scratch_buf) & 0xf);
-#else
-            void *scratch_buf = memalign(16, scratch_buf_size);
-            int align_sz = 0;
-#endif
-            if (scratch_buf == NULL) {
-                printf(ANSI_COLOR_RED"%s scratch_buf alloc failed size %d\n"ANSI_COLOR_RESET, __FUNCTION__, scratch_buf_size);
-                goto conv_s8_cleanup;
-            }
-            esp_nn_set_conv_scratch_buf(scratch_buf + align_sz);
-        }
-
-        if (itr == 0) {
-            /* enable profiler */
-            profile_c_start();
-        }
-
-        /* C function */
-        esp_nn_conv_s8_ansi(input, in_wd, in_ht, in_channels, input_offset,
-                            pad_wd, pad_ht, stride_wd, stride_ht,
-                            filter_data + 2, filter_wd, filter_ht, bias,
-                            out_data_c, out_wd, out_ht, out_channels, out_offset, out_shift,
-                            out_mult, activation_min, activation_max);
-
-        if (itr == 0) {
-            profile_c_end();
-            profile_opt_start();
-        }
-
-        /* Optimized function */
-        esp_nn_conv_s8(input, in_wd, in_ht, in_channels, input_offset,
-                    pad_wd, pad_ht, stride_wd, stride_ht,
-                    filter_data + 2, filter_wd, filter_ht, bias,
-                    out_data_opt, out_wd, out_ht, out_channels, out_offset, out_shift,
-                    out_mult, activation_min, activation_max);
-
-        if (itr == 0) {
-            /* disable profiler */
-            profile_opt_end();
-        }
-
-        bool ret = CHECK_EQUAL(out_data_c, out_data_opt, out_size);
-        if (ret == false) {
-            printf(ANSI_COLOR_RED"%s[%d] failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            printf("Output: \n");
-            PRINT_ARRAY_HEX(out_data_opt, out_size / out_ht, out_ht);
-            printf("Expected: \n");
-            PRINT_ARRAY_HEX(out_data_c, out_size / out_ht, out_ht);
-            printf("Input:\n");
-            PRINT_ARRAY_HEX(input, in_size / in_ht, in_ht);
-            printf("Filter data:\n");
-            PRINT_ARRAY_HEX(filter_data + 2, (filter_size - 2) / filter_ht, filter_ht);
-            printf("bias data:\n");
-            PRINT_ARRAY_INT(bias, out_channels, 1);
-            goto conv_s8_cleanup;
-        }
-        printf(ANSI_COLOR_GREEN"%s[%d] passed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-
-    conv_s8_cleanup:
-        if (input) {
-            free(input_orig);
-        }
-        if (filter_data) {
-            free(filter_data);
-        }
-        if (out_data_c) {
-            free(out_c_orig);
-        }
-        if (out_data_opt) {
-            free(out_opt_orig);
-        }
-        if (bias) {
-            free(bias);
-        }
-        if (out_shift) {
-            free(out_shift);
-        }
-        if (out_mult) {
-            free(out_mult);
-        }
-        if (scratch_buf) {
-            free(scratch_buf);
-        }
-    }
-}

code/components/esp-nn/tests/src/fully_connected_test.c

@@ -1,111 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <esp_nn.h>
-#include "test_utils.h"
-
-
-void esp_nn_fully_connected_s8_test()
-{
-    /* prepare data */
-    static uint16_t row_len = 256 + 8 + 7; /* odd len to test unaligned+left-over */
-    static uint16_t out_channels = 3;
-    int8_t input[row_len];
-    int8_t filter_data[row_len * out_channels];
-    int8_t output_c[out_channels], output_opt[out_channels];
-    static int32_t activation_min = -128;
-    static int32_t activation_max = 127;
-    static int32_t input_offset = 0;
-    static int32_t filter_offset = 0;
-    int32_t out_shift = -10;
-    static int32_t out_offset = 127;
-    int32_t out_mult = 0x59e492c4;
-    for (int itr = 0; itr < 5; itr++) {
-        out_mult = INT32_MAX / row_len + rand() % INT16_MAX;
-        switch (itr) {
-        case 0:
-            out_shift = -10;
-            break;
-        case 1:
-            out_shift = SHIFT_MIN;
-            break;
-        case 2:
-            out_shift = SHIFT_MAX;
-            break;
-        case 3:
-            out_shift = 0;
-            break;
-        default:
-            out_shift = -10 + rand() % 5;
-            break;
-        }
-        if (itr == 0) {
-            out_shift = SHIFT_MAX;
-        }
-        /* Generate input and filter data */
-        for (int i = 0; i < row_len; ++i) {
-            input[i] = rand() % 256 - 128;
-        }
-        for (int i = 0; i < row_len * out_channels; ++i) {
-            filter_data[i] = rand() % 256 - 128;
-        }
-
-        if (itr == 0) {
-            /* enable profiler */
-            profile_c_start();
-        }
-
-        /* C function */
-        esp_nn_fully_connected_s8_ansi(input, input_offset, row_len, filter_data, filter_offset,
-                                    NULL, output_c, out_channels, out_offset, out_shift, out_mult,
-                                    activation_min, activation_max);
-
-        if (itr == 0) {
-            profile_c_end();
-            profile_opt_start();
-        }
-
-        /* Optimized function */
-        esp_nn_fully_connected_s8(input, input_offset, row_len, filter_data, filter_offset,
-                                NULL, output_opt, out_channels, out_offset, out_shift, out_mult,
-                                activation_min, activation_max);
-
-        if (itr == 0) {
-            /* disable profiler */
-            profile_opt_end();
-        }
-
-        bool ret = CHECK_EQUAL(output_c, output_opt, out_channels);
-        if (ret == false) {
-            printf(ANSI_COLOR_RED"%s[%d] failed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-            printf("Output: \n");
-            PRINT_ARRAY_HEX(output_opt, out_channels, 1);
-            printf("Expected: \n");
-            PRINT_ARRAY_HEX(output_c, out_channels, 1);
-            printf("Input:\n");
-            PRINT_ARRAY_HEX(input, row_len, 1);
-            printf("Filter data:\n");
-            PRINT_ARRAY_HEX(filter_data, row_len, out_channels);
-            printf("Out shift: %d\n", out_shift);
-            printf("Out mult: %x\n", out_mult);
-            return;
-        }
-        printf(ANSI_COLOR_GREEN"%s[%d] passed\n"ANSI_COLOR_RESET, __FUNCTION__, itr);
-    }
-}

code/components/esp-nn/tests/src/pooling_test.c

@@ -1,184 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-
-#include <esp_nn.h>
-#include "test_utils.h"
-
-
-void esp_nn_avg_pool_s8_test()
-{
-    /* prepare data */
-    const uint16_t input_wd = 16;
-    const uint16_t input_ht = 16;
-    const uint16_t channels = 16; /* With TFLite example, I have seen it 256 */
-    const int size = input_wd * input_ht * channels;
-    int8_t *input, *output_c, *output_opt;
-    const int32_t activation_min = -128;
-    const int32_t activation_max = 127;
-    const uint16_t pad_wd = 1;
-    const uint16_t pad_ht = 1;
-    const uint16_t stride_wd = 1;
-    const uint16_t stride_ht = 1;
-    const uint16_t filter_ht = 3;
-    const uint16_t filter_wd = 3;
-    const uint16_t out_wd = input_wd / stride_wd;
-    const uint16_t out_ht = input_ht / stride_ht;
-    const int out_size = out_wd * out_ht * channels;
-
-    input = memalign(16, size);
-    output_c = memalign(16, out_size);
-    output_opt = memalign(16, out_size);
-
-    if (input == NULL || output_c == NULL || output_opt == NULL) {
-        printf(ANSI_COLOR_RED"%s allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        goto avg_pool_s8_cleanup;
-    }
-    /**
-     * width/height, channels etc look suspicious but it it true.
-     * It actually depends upon where in model this is actually placed.
-     * If at the end wd/ht tends to be smaller and depth larger.
-     */
-
-    for (int i = 0; i < size; ++i) {
-        input[i] = rand() % 256 - 128;
-    }
-
-    /* enable profiler */
-    profile_c_start();
-
-    /* C function */
-    esp_nn_avg_pool_s8_ansi(input, input_wd, input_ht, output_c, out_wd, out_ht,
-                              stride_wd, stride_ht, filter_wd, filter_ht, pad_wd, pad_ht,
-                              activation_min, activation_max, channels);
-
-    profile_c_end();
-    profile_opt_start();
-
-    /* Optimized function */
-    esp_nn_avg_pool_s8(input, input_wd, input_ht, output_opt, out_wd, out_ht,
-                         stride_wd, stride_ht, filter_wd, filter_ht, pad_wd, pad_ht,
-                         activation_min, activation_max, channels);
-
-    /* disable profiler */
-    profile_opt_end();
-
-
-    bool ret = CHECK_EQUAL(output_c, output_opt, out_size);
-    if (ret == false) {
-        printf(ANSI_COLOR_RED"%s failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        printf("Output: \n");
-        PRINT_ARRAY_HEX(output_opt, out_wd * channels, out_ht);
-        printf("Expected: \n");
-        PRINT_ARRAY_HEX(output_c, out_wd * channels, out_ht);
-        printf("Input:\n");
-        PRINT_ARRAY_HEX(input, input_wd * channels, input_ht);
-        goto avg_pool_s8_cleanup;
-    }
-    printf(ANSI_COLOR_GREEN"%s passed\n"ANSI_COLOR_RESET, __FUNCTION__);
-
-avg_pool_s8_cleanup:
-    if (input) {
-        free(input);
-    }
-    if (output_c) {
-        free(output_c);
-    }
-    if (output_opt) {
-        free(output_opt);
-    }
-}
-
-void esp_nn_max_pool_s8_test()
-{
-    /* prepare data */
-    const uint16_t input_wd = 16;
-    const uint16_t input_ht = 16;
-    const uint16_t channels = 16; /* With TFLite example, I have seen it 256 */
-    int8_t *input, *output_c, *output_opt;
-    const int size = input_wd * input_ht * channels;
-    const int32_t activation_min = -128;
-    const int32_t activation_max = 127;
-    const uint16_t pad_wd = 1;
-    const uint16_t pad_ht = 1;
-    const uint16_t stride_wd = 1;
-    const uint16_t stride_ht = 1;
-    const uint16_t filter_ht = 3;
-    const uint16_t filter_wd = 3;
-    const uint16_t out_wd = input_wd / stride_wd;
-    const uint16_t out_ht = input_ht / stride_ht;
-    const int out_size = out_wd * out_ht * channels;
-
-    input = memalign(16, size);
-    output_c = memalign(16, out_size);
-    output_opt = memalign(16, out_size);
-
-    if (input == NULL || output_c == NULL || output_opt == NULL) {
-        printf(ANSI_COLOR_RED"%s allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        goto max_pool_s8_cleanup;
-    }
-
-    for (int i = 0; i < size; ++i) {
-        input[i] = rand() % 256 - 128;
-    }
-
-    /* enable profiler */
-    profile_c_start();
-
-    /* C function */
-    esp_nn_max_pool_s8_ansi(input, input_wd, input_ht, output_c, out_wd, out_ht,
-                            stride_wd, stride_ht, filter_wd, filter_ht, pad_wd, pad_ht,
-                            activation_min, activation_max, channels);
-
-    profile_c_end();
-    profile_opt_start();
-
-    /* Optimized function */
-    esp_nn_max_pool_s8(input, input_wd, input_ht, output_opt, out_wd, out_ht,
-                       stride_wd, stride_ht, filter_wd, filter_ht, pad_wd, pad_ht,
-                       activation_min, activation_max, channels);
-
-    /* disable profiler */
-    profile_opt_end();
-
-
-    bool ret = CHECK_EQUAL(output_c, output_opt, out_wd * out_ht * channels);
-    if (ret == false) {
-        printf(ANSI_COLOR_RED"%s failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        printf("Output: \n");
-        PRINT_ARRAY_HEX(output_opt, out_wd * out_ht * channels, 1);
-        printf("Expected: \n");
-        PRINT_ARRAY_HEX(output_c, out_wd * out_ht * channels, 1);
-        printf("Input:\n");
-        PRINT_ARRAY_HEX(input, 8, size / 8);
-        goto max_pool_s8_cleanup;
-    }
-    printf(ANSI_COLOR_GREEN"%s passed\n"ANSI_COLOR_RESET, __FUNCTION__);
-
-max_pool_s8_cleanup:
-    if (input) {
-        free(input);
-    }
-    if (output_c) {
-        free(output_c);
-    }
-    if (output_opt) {
-        free(output_opt);
-    }
-}

code/components/esp-nn/tests/src/relu_test.c

@@ -1,83 +0,0 @@
-// Copyright 2020-2021 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-
-#include <esp_nn.h>
-#include "test_utils.h"
-
-void esp_nn_relu6_s8_test()
-{
-    const int size = 1600 + 8 + 7;
-    int8_t *input, *inout_ansi, *inout_opt;
-
-    input = memalign(16, size);
-    inout_ansi = memalign(16, size);
-    inout_opt = memalign(16, size);
-
-    if (input == NULL || inout_ansi == NULL || inout_opt == NULL) {
-        printf(ANSI_COLOR_RED"%s allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        goto relu6_s8_cleanup;
-    }
-    /* Generate filter data between -128 -> +127 */
-    for (int i = 0; i < size; ++i) {
-        input[i] = rand() % 255 - 128;
-        inout_ansi[i] = input[i];
-        inout_opt[i] = input[i];
-    }
-
-    /* enable profiler */
-    profile_c_start();
-
-    /* C function */
-    esp_nn_relu6_s8_ansi(inout_ansi, size);
-
-    profile_c_end();
-    profile_opt_start();
-
-    /* Optimized function */
-    esp_nn_relu6_s8(inout_opt, size);
-
-    /* disable profiler */
-    profile_opt_end();
-
-    bool ret = CHECK_EQUAL(inout_ansi, inout_opt, size);
-    if (ret == false) {
-        printf(ANSI_COLOR_RED"%s failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        printf("Output: \n");
-        PRINT_ARRAY_HEX(inout_opt, size, 1);
-        printf("Expected: \n");
-        PRINT_ARRAY_HEX(inout_ansi, size, 1);
-        printf("Input:\n");
-        PRINT_ARRAY_HEX(input, size, 1);
-        goto relu6_s8_cleanup;
-    }
-    printf(ANSI_COLOR_GREEN"%s passed\n"ANSI_COLOR_RESET, __FUNCTION__);
-
-relu6_s8_cleanup:
-    if (input) {
-        free (input);
-    }
-    if (inout_ansi) {
-        free (inout_ansi);
-    }
-    if (inout_opt) {
-        free (inout_opt);
-    }
-
-}

code/components/esp-nn/tests/src/softmax_test.c

@@ -1,101 +0,0 @@
-// Copyright 2022 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 <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-
-#include <esp_nn.h>
-#include "test_utils.h"
-
-void esp_nn_softmax_s8_test()
-{
-    const int32_t height = 8;
-    const int32_t width = 32;
-    const int32_t diff_min = -128;
-    const int32_t mult = INT32_MAX / 2;
-    const int32_t shift = 7;
-    void *scratch_buf = NULL;
-    const int size = width * height;
-    int8_t *input, *out_ansi, *out_opt;
-
-    input = memalign(16, size);
-    out_ansi = memalign(16, size);
-    out_opt = memalign(16, size);
-
-    if (input == NULL || out_ansi == NULL || out_opt == NULL) {
-        printf(ANSI_COLOR_RED"%s buffer allocations failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        goto softmax_s8_cleanup;
-    }
-
-    /* Generate input data between -128 -> +127 */
-    for (int i = 0; i < size; ++i) {
-        input[i] = rand() % 255 - 128;
-    }
-
-    /* enable profiler */
-    profile_c_start();
-
-    /* C function */
-    esp_nn_softmax_s8_ansi(input, height, width, mult, shift, diff_min, out_ansi);
-
-    profile_c_end();
-
-    int32_t scratch_buf_size = esp_nn_get_softmax_scratch_size(width, height);
-    if (scratch_buf_size) {
-        scratch_buf = memalign(4, scratch_buf_size);
-        if (scratch_buf == NULL) {
-            printf(ANSI_COLOR_RED"%s scratch_buf alloc failed size %d\n"ANSI_COLOR_RESET, __FUNCTION__, scratch_buf_size);
-            goto softmax_s8_cleanup;
-        }
-        esp_nn_set_softmax_scratch_buf(scratch_buf);
-    }
-
-    profile_opt_start();
-
-    /* Optimized function */
-    esp_nn_softmax_s8(input, height, width, mult, shift, diff_min, out_opt);
-
-    /* disable profiler */
-    profile_opt_end();
-
-    bool ret = CHECK_EQUAL(out_ansi, out_opt, size);
-    if (ret == false) {
-        printf(ANSI_COLOR_RED"%s failed\n"ANSI_COLOR_RESET, __FUNCTION__);
-        printf("Output: \n");
-        PRINT_ARRAY_HEX(out_opt, width, height);
-        printf("Expected: \n");
-        PRINT_ARRAY_HEX(out_ansi, width, height);
-        printf("Input:\n");
-        PRINT_ARRAY_HEX(input, width, height);
-        goto softmax_s8_cleanup;
-    }
-    printf(ANSI_COLOR_GREEN"%s passed\n"ANSI_COLOR_RESET, __FUNCTION__);
-
-softmax_s8_cleanup:
-    if (input) {
-        free (input);
-    }
-    if (out_ansi) {
-        free (out_ansi);
-    }
-    if (out_opt) {
-        free (out_opt);
-    }
-    if (scratch_buf) {
-        free (scratch_buf);
-    }
-}

code/components/esp32-camera-master/.github/workflows/build.yml

@@ -1,79 +0,0 @@
-name: Build examples
-on:
-  push:
-    branches:
-    - master
-  pull_request:
-
-jobs:
-  build-master:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@latest
-      with:
-        path: 'examples'
-
-  build-release-v4_0:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@release-v4.0
-      with:
-        path: 'examples'
-
-  build-release-v4_1:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@release-v4.1
-      with:
-        path: 'examples'
-
-  build-release-v4_2:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@release-v4.2
-      with:
-        path: 'examples'
-
-  build-release-v4_3:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@release-v4.3
-      with:
-        path: 'examples'
-
-  build-release-v3_3:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repo
-      uses: actions/checkout@v2
-      with:
-        submodules: 'recursive'
-    - name: esp-idf build
-      uses: espressif/esp-idf-ci-action@release-v3.3
-      with:
-        path: 'examples'

code/components/esp32-camera-master/.github/workflows/stale.yml

@@ -1,27 +0,0 @@
-# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
-#
-# You can adjust the behavior by modifying this file.
-# For more information, see:
-# https://github.com/actions/stale
-name: Mark stale issues and pull requests
-
-on:
-  schedule:
-  - cron: '20 9 * * *'
-
-jobs:
-  stale:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-
-    steps:
-    - uses: actions/stale@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'This issue appears to be stale. Please close it if its no longer valid.'
-        stale-pr-message: 'This pull request appears to be stale. Please close it if its no longer valid.'
-        stale-issue-label: 'no-issue-activity'
-        stale-pr-label: 'no-pr-activity'

code/components/esp32-camera-master/.github/workflows/upload_component.yml

@@ -1,21 +0,0 @@
-name: Push component to https://components.espressif.com
-on:
-  push:
-    tags:
-      - v*
-jobs:
-  upload_components:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-        with:
-          submodules: "recursive"
-
-      - name: Upload component to the component registry
-        uses: espressif/github-actions/upload_components@master
-        with:
-          name: "esp32-camera"
-          version: "git"
-          namespace: "espressif"
-          service_url: ${{ secrets.IDF_COMPONENT_API_URL }}
-          api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}

code/components/esp32-camera-master/.gitignore

@@ -1,5 +0,0 @@
-*.DS_Store
-.vscode
-**/build
-**/sdkconfig
-**/sdkconfig.old

code/components/esp32-camera-master/CMakeLists.txt

@@ -1,65 +0,0 @@
-if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET STREQUAL "esp32s3")
-  set(COMPONENT_SRCS
-    driver/esp_camera.c
-    driver/cam_hal.c
-    driver/sccb.c
-    driver/sensor.c
-    sensors/ov2640.c
-    sensors/ov3660.c
-    sensors/ov5640.c
-    sensors/ov7725.c
-    sensors/ov7670.c
-    sensors/nt99141.c
-    sensors/gc0308.c
-    sensors/gc2145.c
-    sensors/gc032a.c
-    sensors/bf3005.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
-    target/private_include
-    )
-
-  if(IDF_TARGET STREQUAL "esp32")
-    list(APPEND COMPONENT_SRCS
-      target/xclk.c
-      target/esp32/ll_cam.c
-      )
-  endif()
-
-  if(IDF_TARGET STREQUAL "esp32s2")
-    list(APPEND COMPONENT_SRCS
-      target/xclk.c
-      target/esp32s2/ll_cam.c
-      target/esp32s2/tjpgd.c
-      )
-
-    list(APPEND COMPONENT_PRIV_INCLUDEDIRS
-      target/esp32s2/private_include
-      )
-  endif()
-
-  if(IDF_TARGET STREQUAL "esp32s3")
-    list(APPEND COMPONENT_SRCS
-      target/esp32s3/ll_cam.c
-      )
-  endif()
-
-  set(COMPONENT_REQUIRES driver)
-  set(COMPONENT_PRIV_REQUIRES freertos nvs_flash)
-
-  register_component()
-endif()

code/components/esp32-camera-master/Kconfig

@@ -1,129 +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 save memory.
-
-    config OV7725_SUPPORT
-        bool "Support OV7725 VGA"
-        default y
-        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.
-
-    config GC2145_SUPPORT
-        bool "Support GC2145 2MP"
-        default y
-        help
-            Enable this option if you want to use the GC2145.
-            Disable this option to save memory.
-
-    config GC032A_SUPPORT
-        bool "Support GC032A VGA"
-        default y
-        help
-            Enable this option if you want to use the GC032A.
-            Disable this option to save memory.
-
-    config GC0308_SUPPORT
-        bool "Support GC0308 VGA"
-        default y
-        help
-            Enable this option if you want to use the GC0308.
-            Disable this option to save memory.
-            
-    config BF3005_SUPPORT
-        bool "Support BF3005(BYD3005) VGA"
-        default y
-        help
-            Enable this option if you want to use the BF3005.
-            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
-
-    config SCCB_CLK_FREQ
-    int "SCCB clk frequency"
-    default 100000
-    range 100000 400000
-    help
-        Increasing this value can reduce the initialization time of the sensor.
-        Please refer to the relevant instructions of the sensor to adjust the value.
-    
-    choice GC_SENSOR_WINDOW_MODE
-        bool "GalaxyCore Sensor Window Mode"
-        depends on (GC2145_SUPPORT || GC032A_SUPPORT || GC0308_SUPPORT)
-        default GC_SENSOR_SUBSAMPLE_MODE
-        help
-            This option determines how to reduce the output size when the resolution you set is less than the maximum resolution.
-            SUBSAMPLE_MODE has a bigger perspective and WINDOWING_MODE has a higher frame rate.
-
-        config GC_SENSOR_WINDOWING_MODE
-            bool "Windowing Mode"
-        config GC_SENSOR_SUBSAMPLE_MODE
-            bool "Subsample Mode"
-    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
-
-    config CAMERA_DMA_BUFFER_SIZE_MAX
-        int "DMA buffer size"
-        range 8192 32768
-        default 32768
-        help
-            Maximum value of DMA buffer
-            Larger values may fail to allocate due to insufficient contiguous memory blocks, and smaller value may cause DMA interrupt to be too frequent
-
-endmenu

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.

code/components/esp32-camera-master/README.md

@@ -1,369 +0,0 @@
-# ESP32 Camera Driver
-
-[![Build examples](https://github.com/espressif/esp32-camera/actions/workflows/build.yml/badge.svg)](https://github.com/espressif/esp32-camera/actions/workflows/build.yml)
-## General Information
-
-This repository hosts ESP32 series Soc compatible driver for image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
-
-### Supported Soc
-
-- ESP32
-- ESP32-S2
-- ESP32-S3
-
-### Supported Sensor
-
-| model   | max resolution | color type | output format                                                | Len Size |
-| ------- | -------------- | ---------- | ------------------------------------------------------------ | -------- |
-| OV2640  | 1600 x 1200    | color      | YUV(422/420)/YCbCr422<br>RGB565/555<br>8-bit compressed data<br>8/10-bit Raw RGB data | 1/4"     |
-| OV3660  | 2048 x 1536    | color      | raw RGB data<br/>RGB565/555/444<br/>CCIR656<br/>YCbCr422<br/>compression | 1/5"     |
-| OV5640  | 2592 x 1944    | color      | RAW RGB<br/>RGB565/555/444<br/>CCIR656<br/>YUV422/420<br/>YCbCr422<br/>compression | 1/4"     |
-| OV7670  | 640 x 480      | color      | Raw Bayer RGB<br/>Processed Bayer RGB<br>YUV/YCbCr422<br>GRB422<br>RGB565/555 | 1/6"     |
-| OV7725  | 640 x 480      | color      | Raw RGB<br/>GRB 422<br/>RGB565/555/444<br/>YCbCr 422         | 1/4"     |
-| NT99141 | 1280 x 720     | color      | YCbCr 422<br/>RGB565/555/444<br/>Raw<br/>CCIR656<br/>JPEG compression | 1/4"     |
-| GC032A  | 640 x 480      | color      | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565                        | 1/10"    |
-| GC0308  | 640 x 480      | color      | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565                        | 1/6.5"   |
-| GC2145  | 1600 x 1200    | color      | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565                        | 1/5"     |
-| BF3005  | 640 x 480      | color      | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565                        | 1/4"     |
-
-## 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` (also set Flash and PSRAM frequiencies to 80MHz)
-- 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! 
-
-
-## 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_freq_hz = 20000000,//EXPERIMENTAL: Set to 16MHz on ESP32-S2 or ESP32-S3 to enable EDMA mode
-    .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
-    .grab_mode = CAMERA_GRAB_WHEN_EMPTY//CAMERA_GRAB_LATEST. Sets when buffers should be filled
-};
-
-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;
-}
-```
-
-
-

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 target/private_include
-COMPONENT_SRCDIRS := driver conversions sensors target target/esp32
-CXXFLAGS += -fno-rtti

code/components/esp32-camera-master/conversions/esp_jpg_decode.c

@@ -1,132 +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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "tjpgd.h"
-#elif CONFIG_IDF_TARGET_ESP32S3
-#include "esp32s3/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;
-}
-

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_ */

code/components/esp32-camera-master/conversions/include/img_converters.h

@@ -1,130 +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"
-#include "esp_jpg_decode.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);
-
-bool jpg2rgb565(const uint8_t *src, size_t src_len, uint8_t * out, jpg_scale_t scale);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _IMG_CONVERTERS_H_ */

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

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

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_ */

code/components/esp32-camera-master/conversions/to_bmp.c

@@ -1,393 +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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/spiram.h"
-#elif CONFIG_IDF_TARGET_ESP32S3
-#include "esp32s3/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;
-}
-
-static bool _rgb565_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 jw2 = jpeg->width*2;
-    size_t t = y * jw;
-    size_t t2 = y * jw2;
-    size_t b = t + (h * jw);
-    size_t l = x * 2;
-    uint8_t *out = jpeg->output+jpeg->data_offset;
-    uint8_t *o = out;
-    size_t iy, iy2, ix, ix2;
-
-    w = w * 3;
-
-    for(iy=t, iy2=t2; iy<b; iy+=jw, iy2+=jw2) {
-        o = out+iy2+l;
-        for(ix2=ix=0; ix<w; ix+= 3, ix2 +=2) {
-            uint16_t r = data[ix];
-            uint16_t g = data[ix+1];
-            uint16_t b = data[ix+2];
-            uint16_t c = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
-            o[ix2+1] = c>>8;
-            o[ix2] = c&0xff;
-        }
-        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 jpg2rgb565(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, _rgb565_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);
-}

code/components/esp32-camera-master/conversions/to_jpg.cpp

@@ -1,245 +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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/spiram.h"
-#elif CONFIG_IDF_TARGET_ESP32S3
-#include "esp32s3/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 (%d,%d,%d)", len - (max_len - index), len, index, max_len);
-            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 = 128*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);
-}

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);
-}

code/components/esp32-camera-master/driver/cam_hal.c

@@ -1,483 +0,0 @@
-// Copyright 2010-2020 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 <stdio.h>
-#include <string.h>
-#include "esp_heap_caps.h"
-#include "ll_cam.h"
-#include "cam_hal.h"
-
-static const char *TAG = "cam_hal";
-
-static cam_obj_t *cam_obj = NULL;
-
-static const uint32_t JPEG_SOI_MARKER = 0xFFD8FF;  // written in little-endian for esp32
-static const uint16_t JPEG_EOI_MARKER = 0xD9FF;  // written in little-endian for esp32
-
-static int cam_verify_jpeg_soi(const uint8_t *inbuf, uint32_t length)
-{
-    uint32_t sig = *((uint32_t *)inbuf) & 0xFFFFFF;
-    if(sig != JPEG_SOI_MARKER) {
-        for (uint32_t i = 0; i < length; i++) {
-            sig = *((uint32_t *)(&inbuf[i])) & 0xFFFFFF;
-            if (sig == JPEG_SOI_MARKER) {
-                ESP_LOGW(TAG, "SOI: %d", i);
-                return i;
-            }
-        }
-        ESP_LOGW(TAG, "NO-SOI");
-        return -1;
-    }
-    return 0;
-}
-
-static int cam_verify_jpeg_eoi(const uint8_t *inbuf, uint32_t length)
-{
-    int offset = -1;
-    uint8_t *dptr = (uint8_t *)inbuf + length - 2;
-    while (dptr > inbuf) {
-        uint16_t sig = *((uint16_t *)dptr);
-        if (JPEG_EOI_MARKER == sig) {
-            offset = dptr - inbuf;
-            //ESP_LOGW(TAG, "EOI: %d", length - (offset + 2));
-            return offset;
-        }
-        dptr--;
-    }
-    return -1;
-}
-
-static bool cam_get_next_frame(int * frame_pos)
-{
-    if(!cam_obj->frames[*frame_pos].en){
-        for (int x = 0; x < cam_obj->frame_cnt; x++) {
-            if (cam_obj->frames[x].en) {
-                *frame_pos = x;
-                return true;
-            }
-        }
-    } else {
-        return true;
-    }
-    return false;
-}
-
-static bool cam_start_frame(int * frame_pos)
-{
-    if (cam_get_next_frame(frame_pos)) {
-        if(ll_cam_start(cam_obj, *frame_pos)){
-            // Vsync the frame manually
-            ll_cam_do_vsync(cam_obj);
-            uint64_t us = (uint64_t)esp_timer_get_time();
-            cam_obj->frames[*frame_pos].fb.timestamp.tv_sec = us / 1000000UL;
-            cam_obj->frames[*frame_pos].fb.timestamp.tv_usec = us % 1000000UL;
-            return true;
-        }
-    }
-    return false;
-}
-
-void IRAM_ATTR ll_cam_send_event(cam_obj_t *cam, cam_event_t cam_event, BaseType_t * HPTaskAwoken)
-{
-    if (xQueueSendFromISR(cam->event_queue, (void *)&cam_event, HPTaskAwoken) != pdTRUE) {
-        ll_cam_stop(cam);
-        cam->state = CAM_STATE_IDLE;
-        ESP_EARLY_LOGE(TAG, "EV-%s-OVF", cam_event==CAM_IN_SUC_EOF_EVENT ? "EOF" : "VSYNC");
-    }
-}
-
-//Copy fram from DMA dma_buffer to fram dma_buffer
-static void cam_task(void *arg)
-{
-    int cnt = 0;
-    int frame_pos = 0;
-    cam_obj->state = CAM_STATE_IDLE;
-    cam_event_t cam_event = 0;
-    
-    xQueueReset(cam_obj->event_queue);
-
-    while (1) {
-        xQueueReceive(cam_obj->event_queue, (void *)&cam_event, portMAX_DELAY);
-        DBG_PIN_SET(1);
-        switch (cam_obj->state) {
-
-            case CAM_STATE_IDLE: {
-                if (cam_event == CAM_VSYNC_EVENT) {
-                    //DBG_PIN_SET(1);
-                    if(cam_start_frame(&frame_pos)){
-                        cam_obj->frames[frame_pos].fb.len = 0;
-                        cam_obj->state = CAM_STATE_READ_BUF;
-                    }
-                    cnt = 0;
-                }
-            }
-            break;
-
-            case CAM_STATE_READ_BUF: {
-                camera_fb_t * frame_buffer_event = &cam_obj->frames[frame_pos].fb;
-                size_t pixels_per_dma = (cam_obj->dma_half_buffer_size * cam_obj->fb_bytes_per_pixel) / (cam_obj->dma_bytes_per_item * cam_obj->in_bytes_per_pixel);
-                
-                if (cam_event == CAM_IN_SUC_EOF_EVENT) {
-                    if(!cam_obj->psram_mode){
-                        if (cam_obj->fb_size < (frame_buffer_event->len + pixels_per_dma)) {
-                            ESP_LOGW(TAG, "FB-OVF");
-                            ll_cam_stop(cam_obj);
-                            DBG_PIN_SET(0);
-                            continue;
-                        }
-                        frame_buffer_event->len += ll_cam_memcpy(cam_obj,
-                            &frame_buffer_event->buf[frame_buffer_event->len], 
-                            &cam_obj->dma_buffer[(cnt % cam_obj->dma_half_buffer_cnt) * cam_obj->dma_half_buffer_size], 
-                            cam_obj->dma_half_buffer_size);
-                    }
-                    //Check for JPEG SOI in the first buffer. stop if not found
-                    if (cam_obj->jpeg_mode && cnt == 0 && cam_verify_jpeg_soi(frame_buffer_event->buf, frame_buffer_event->len) != 0) {
-                        ll_cam_stop(cam_obj);
-                        cam_obj->state = CAM_STATE_IDLE;
-                    }
-                    cnt++;
-
-                } else if (cam_event == CAM_VSYNC_EVENT) {
-                    //DBG_PIN_SET(1);
-                    ll_cam_stop(cam_obj);
-
-                    if (cnt || !cam_obj->jpeg_mode || cam_obj->psram_mode) {
-                        if (cam_obj->jpeg_mode) {
-                            if (!cam_obj->psram_mode) {
-                                if (cam_obj->fb_size < (frame_buffer_event->len + pixels_per_dma)) {
-                                    ESP_LOGW(TAG, "FB-OVF");
-                                    cnt--;
-                                } else {
-                                    frame_buffer_event->len += ll_cam_memcpy(cam_obj,
-                                        &frame_buffer_event->buf[frame_buffer_event->len], 
-                                        &cam_obj->dma_buffer[(cnt % cam_obj->dma_half_buffer_cnt) * cam_obj->dma_half_buffer_size], 
-                                        cam_obj->dma_half_buffer_size);
-                                }
-                            }
-                            cnt++;
-                        }
-
-                        cam_obj->frames[frame_pos].en = 0;
-
-                        if (cam_obj->psram_mode) {
-                            if (cam_obj->jpeg_mode) {
-                                frame_buffer_event->len = cnt * cam_obj->dma_half_buffer_size;
-                            } else {
-                                frame_buffer_event->len = cam_obj->recv_size;
-                            }
-                        } else if (!cam_obj->jpeg_mode) {
-                            if (frame_buffer_event->len != cam_obj->fb_size) {
-                                cam_obj->frames[frame_pos].en = 1;
-                                ESP_LOGE(TAG, "FB-SIZE: %u != %u", frame_buffer_event->len, cam_obj->fb_size);
-                            }
-                        }
-                        //send frame
-                        if(!cam_obj->frames[frame_pos].en && xQueueSend(cam_obj->frame_buffer_queue, (void *)&frame_buffer_event, 0) != pdTRUE) {
-                            //pop frame buffer from the queue
-                            camera_fb_t * fb2 = NULL;
-                            if(xQueueReceive(cam_obj->frame_buffer_queue, &fb2, 0) == pdTRUE) {
-                                //push the new frame to the end of the queue
-                                if (xQueueSend(cam_obj->frame_buffer_queue, (void *)&frame_buffer_event, 0) != pdTRUE) {
-                                    cam_obj->frames[frame_pos].en = 1;
-                                    ESP_LOGE(TAG, "FBQ-SND");
-                                }
-                                //free the popped buffer
-                                cam_give(fb2);
-                            } else {
-                                //queue is full and we could not pop a frame from it
-                                cam_obj->frames[frame_pos].en = 1;
-                                ESP_LOGE(TAG, "FBQ-RCV");
-                            }
-                        }
-                    }
-
-                    if(!cam_start_frame(&frame_pos)){
-                        cam_obj->state = CAM_STATE_IDLE;
-                    } else {
-                        cam_obj->frames[frame_pos].fb.len = 0;
-                    }
-                    cnt = 0;
-                }
-            }
-            break;
-        }
-        DBG_PIN_SET(0);
-    }
-}
-
-static lldesc_t * allocate_dma_descriptors(uint32_t count, uint16_t size, uint8_t * buffer)
-{
-    lldesc_t *dma = (lldesc_t *)heap_caps_malloc(count * sizeof(lldesc_t), MALLOC_CAP_DMA);
-    if (dma == NULL) {
-        return dma;
-    }
-
-    for (int x = 0; x < count; x++) {
-        dma[x].size = size;
-        dma[x].length = 0;
-        dma[x].sosf = 0;
-        dma[x].eof = 0;
-        dma[x].owner = 1;
-        dma[x].buf = (buffer + size * x);
-        dma[x].empty = (uint32_t)&dma[(x + 1) % count];
-    }
-    return dma;
-}
-
-static esp_err_t cam_dma_config(const camera_config_t *config)
-{
-    bool ret = ll_cam_dma_sizes(cam_obj);
-    if (0 == ret) {
-        return ESP_FAIL;
-    }
-
-    cam_obj->dma_node_cnt = (cam_obj->dma_buffer_size) / cam_obj->dma_node_buffer_size; // Number of DMA nodes
-    cam_obj->frame_copy_cnt = cam_obj->recv_size / cam_obj->dma_half_buffer_size; // Number of interrupted copies, ping-pong copy
-
-    ESP_LOGI(TAG, "buffer_size: %d, half_buffer_size: %d, node_buffer_size: %d, node_cnt: %d, total_cnt: %d", 
-             cam_obj->dma_buffer_size, cam_obj->dma_half_buffer_size, cam_obj->dma_node_buffer_size, cam_obj->dma_node_cnt, cam_obj->frame_copy_cnt);
-
-    cam_obj->dma_buffer = NULL;
-    cam_obj->dma = NULL;
-
-    cam_obj->frames = (cam_frame_t *)heap_caps_calloc(1, cam_obj->frame_cnt * sizeof(cam_frame_t), MALLOC_CAP_DEFAULT);
-    CAM_CHECK(cam_obj->frames != NULL, "frames malloc failed", ESP_FAIL);
-
-    uint8_t dma_align = 0;
-    size_t fb_size = cam_obj->fb_size;
-    if (cam_obj->psram_mode) {
-        dma_align = ll_cam_get_dma_align(cam_obj);
-        if (cam_obj->fb_size < cam_obj->recv_size) {
-            fb_size = cam_obj->recv_size;
-        }
-    }
-
-    /* Allocate memory for frame buffer */
-    size_t alloc_size = fb_size * sizeof(uint8_t) + dma_align;
-    uint32_t _caps = MALLOC_CAP_8BIT;
-    if (CAMERA_FB_IN_DRAM == config->fb_location) {
-        _caps |= MALLOC_CAP_INTERNAL;
-    } else {
-        _caps |= MALLOC_CAP_SPIRAM;
-    }
-    for (int x = 0; x < cam_obj->frame_cnt; x++) {
-        cam_obj->frames[x].dma = NULL;
-        cam_obj->frames[x].fb_offset = 0;
-        cam_obj->frames[x].en = 0;
-        ESP_LOGI(TAG, "Allocating %d Byte frame buffer in %s", alloc_size, _caps & MALLOC_CAP_SPIRAM ? "PSRAM" : "OnBoard RAM");
-        cam_obj->frames[x].fb.buf = (uint8_t *)heap_caps_malloc(alloc_size, _caps);
-        CAM_CHECK(cam_obj->frames[x].fb.buf != NULL, "frame buffer malloc failed", ESP_FAIL);
-        if (cam_obj->psram_mode) {
-            //align PSRAM buffer. TODO: save the offset so proper address can be freed later
-            cam_obj->frames[x].fb_offset = dma_align - ((uint32_t)cam_obj->frames[x].fb.buf & (dma_align - 1));
-            cam_obj->frames[x].fb.buf += cam_obj->frames[x].fb_offset;
-            ESP_LOGI(TAG, "Frame[%d]: Offset: %u, Addr: 0x%08X", x, cam_obj->frames[x].fb_offset, (uint32_t)cam_obj->frames[x].fb.buf);
-            cam_obj->frames[x].dma = allocate_dma_descriptors(cam_obj->dma_node_cnt, cam_obj->dma_node_buffer_size, cam_obj->frames[x].fb.buf);
-            CAM_CHECK(cam_obj->frames[x].dma != NULL, "frame dma malloc failed", ESP_FAIL);
-        }
-        cam_obj->frames[x].en = 1;
-    }
-
-    if (!cam_obj->psram_mode) {
-        cam_obj->dma_buffer = (uint8_t *)heap_caps_malloc(cam_obj->dma_buffer_size * sizeof(uint8_t), MALLOC_CAP_DMA);
-        if(NULL == cam_obj->dma_buffer) {
-            ESP_LOGE(TAG,"%s(%d): DMA buffer %d Byte malloc failed, the current largest free block:%d Byte", __FUNCTION__, __LINE__, 
-                     cam_obj->dma_buffer_size, heap_caps_get_largest_free_block(MALLOC_CAP_DMA));
-            return ESP_FAIL;
-        }
-
-        cam_obj->dma = allocate_dma_descriptors(cam_obj->dma_node_cnt, cam_obj->dma_node_buffer_size, cam_obj->dma_buffer);
-        CAM_CHECK(cam_obj->dma != NULL, "dma malloc failed", ESP_FAIL);
-    }
-
-    return ESP_OK;
-}
-
-esp_err_t cam_init(const camera_config_t *config)
-{
-    CAM_CHECK(NULL != config, "config pointer is invalid", ESP_ERR_INVALID_ARG);
-
-    esp_err_t ret = ESP_OK;
-    cam_obj = (cam_obj_t *)heap_caps_calloc(1, sizeof(cam_obj_t), MALLOC_CAP_DMA);
-    CAM_CHECK(NULL != cam_obj, "lcd_cam object malloc error", ESP_ERR_NO_MEM);
-
-    cam_obj->swap_data = 0;
-    cam_obj->vsync_pin = config->pin_vsync;
-    cam_obj->vsync_invert = true;
-
-    ll_cam_set_pin(cam_obj, config);
-    ret = ll_cam_config(cam_obj, config);
-    CAM_CHECK_GOTO(ret == ESP_OK, "ll_cam initialize failed", err);
-
-#if CAMERA_DBG_PIN_ENABLE
-    PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[DBG_PIN_NUM], PIN_FUNC_GPIO);
-    gpio_set_direction(DBG_PIN_NUM, GPIO_MODE_OUTPUT);
-    gpio_set_pull_mode(DBG_PIN_NUM, GPIO_FLOATING);
-#endif
-
-    ESP_LOGI(TAG, "cam init ok");
-    return ESP_OK;
-
-err:
-    free(cam_obj);
-    cam_obj = NULL;
-    return ESP_FAIL;
-}
-
-esp_err_t cam_config(const camera_config_t *config, framesize_t frame_size, uint16_t sensor_pid)
-{
-    CAM_CHECK(NULL != config, "config pointer is invalid", ESP_ERR_INVALID_ARG);
-    esp_err_t ret = ESP_OK;
-
-    ret = ll_cam_set_sample_mode(cam_obj, (pixformat_t)config->pixel_format, config->xclk_freq_hz, sensor_pid);
-
-    cam_obj->jpeg_mode = config->pixel_format == PIXFORMAT_JPEG;
-#if CONFIG_IDF_TARGET_ESP32
-    cam_obj->psram_mode = false;
-#else
-    cam_obj->psram_mode = (config->xclk_freq_hz == 16000000);
-#endif
-    cam_obj->frame_cnt = config->fb_count;
-    cam_obj->width = resolution[frame_size].width;
-    cam_obj->height = resolution[frame_size].height;
-
-    if(cam_obj->jpeg_mode){
-        cam_obj->recv_size = cam_obj->width * cam_obj->height / 5;
-        cam_obj->fb_size = cam_obj->recv_size;
-    } else {
-        cam_obj->recv_size = cam_obj->width * cam_obj->height * cam_obj->in_bytes_per_pixel;
-        cam_obj->fb_size = cam_obj->width * cam_obj->height * cam_obj->fb_bytes_per_pixel;
-    }
-    
-    ret = cam_dma_config(config);
-    CAM_CHECK_GOTO(ret == ESP_OK, "cam_dma_config failed", err);
-
-    cam_obj->event_queue = xQueueCreate(cam_obj->dma_half_buffer_cnt - 1, sizeof(cam_event_t));
-    CAM_CHECK_GOTO(cam_obj->event_queue != NULL, "event_queue create failed", err);
-
-    size_t frame_buffer_queue_len = cam_obj->frame_cnt;
-    if (config->grab_mode == CAMERA_GRAB_LATEST && cam_obj->frame_cnt > 1) {
-        frame_buffer_queue_len = cam_obj->frame_cnt - 1;
-    }
-    cam_obj->frame_buffer_queue = xQueueCreate(frame_buffer_queue_len, sizeof(camera_fb_t*));
-    CAM_CHECK_GOTO(cam_obj->frame_buffer_queue != NULL, "frame_buffer_queue create failed", err);
-
-    ret = ll_cam_init_isr(cam_obj);
-    CAM_CHECK_GOTO(ret == ESP_OK, "cam intr alloc failed", err);
-
-    
-#if CONFIG_CAMERA_CORE0
-    xTaskCreatePinnedToCore(cam_task, "cam_task", 2048, NULL, configMAX_PRIORITIES - 2, &cam_obj->task_handle, 0);
-#elif CONFIG_CAMERA_CORE1
-    xTaskCreatePinnedToCore(cam_task, "cam_task", 2048, NULL, configMAX_PRIORITIES - 2, &cam_obj->task_handle, 1);
-#else
-    xTaskCreate(cam_task, "cam_task", 2048, NULL, configMAX_PRIORITIES - 2, &cam_obj->task_handle);
-#endif
-
-    ESP_LOGI(TAG, "cam config ok");
-    return ESP_OK;
-
-err:
-    cam_deinit();
-    return ESP_FAIL;
-}
-
-esp_err_t cam_deinit(void)
-{
-    if (!cam_obj) {
-        return ESP_FAIL;
-    }
-
-    cam_stop();
-    if (cam_obj->task_handle) {
-        vTaskDelete(cam_obj->task_handle);
-    }
-    if (cam_obj->event_queue) {
-        vQueueDelete(cam_obj->event_queue);
-    }
-    if (cam_obj->frame_buffer_queue) {
-        vQueueDelete(cam_obj->frame_buffer_queue);
-    }
-    if (cam_obj->dma) {
-        free(cam_obj->dma);
-    }
-    if (cam_obj->dma_buffer) {
-        free(cam_obj->dma_buffer);
-    }
-    if (cam_obj->frames) {
-        for (int x = 0; x < cam_obj->frame_cnt; x++) {
-            free(cam_obj->frames[x].fb.buf - cam_obj->frames[x].fb_offset);
-            if (cam_obj->frames[x].dma) {
-                free(cam_obj->frames[x].dma);
-            }
-        }
-        free(cam_obj->frames);
-    }
-
-    ll_cam_deinit(cam_obj);
-
-    free(cam_obj);
-    cam_obj = NULL;
-    return ESP_OK;
-}
-
-void cam_stop(void)
-{
-    ll_cam_vsync_intr_enable(cam_obj, false);
-    ll_cam_stop(cam_obj);
-}
-
-void cam_start(void)
-{
-    ll_cam_vsync_intr_enable(cam_obj, true);
-}
-
-camera_fb_t *cam_take(TickType_t timeout)
-{
-    camera_fb_t *dma_buffer = NULL;
-    TickType_t start = xTaskGetTickCount();
-    xQueueReceive(cam_obj->frame_buffer_queue, (void *)&dma_buffer, timeout);
-    if (dma_buffer) {
-        if(cam_obj->jpeg_mode){
-            // find the end marker for JPEG. Data after that can be discarded
-            int offset_e = cam_verify_jpeg_eoi(dma_buffer->buf, dma_buffer->len);
-            if (offset_e >= 0) {
-                // adjust buffer length
-                dma_buffer->len = offset_e + sizeof(JPEG_EOI_MARKER);
-                return dma_buffer;
-            } else {
-                ESP_LOGW(TAG, "NO-EOI");
-                cam_give(dma_buffer);
-                return cam_take(timeout - (xTaskGetTickCount() - start));//recurse!!!!
-            }
-        } else if(cam_obj->psram_mode && cam_obj->in_bytes_per_pixel != cam_obj->fb_bytes_per_pixel){
-            //currently this is used only for YUV to GRAYSCALE
-            dma_buffer->len = ll_cam_memcpy(cam_obj, dma_buffer->buf, dma_buffer->buf, dma_buffer->len);
-        }
-        return dma_buffer;
-    } else {
-        ESP_LOGW(TAG, "Failed to get the frame on time!");
-    }
-    return NULL;
-}
-
-void cam_give(camera_fb_t *dma_buffer)
-{
-    for (int x = 0; x < cam_obj->frame_cnt; x++) {
-        if (&cam_obj->frames[x].fb == dma_buffer) {
-            cam_obj->frames[x].en = 1;
-            break;
-        }
-    }
-}

code/components/esp32-camera-master/driver/esp_camera.c

@@ -1,421 +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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "time.h"
-#include "sys/time.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "driver/gpio.h"
-#include "esp_system.h"
-#include "nvs_flash.h"
-#include "nvs.h"
-#include "sensor.h"
-#include "sccb.h"
-#include "cam_hal.h"
-#include "esp_camera.h"
-#include "xclk.h"
-#if CONFIG_OV2640_SUPPORT
-#include "ov2640.h"
-#endif
-#if CONFIG_OV7725_SUPPORT
-#include "ov7725.h"
-#endif
-#if CONFIG_OV3660_SUPPORT
-#include "ov3660.h"
-#endif
-#if CONFIG_OV5640_SUPPORT
-#include "ov5640.h"
-#endif
-#if CONFIG_NT99141_SUPPORT
-#include "nt99141.h"
-#endif
-#if CONFIG_OV7670_SUPPORT
-#include "ov7670.h"
-#endif
-#if CONFIG_GC2145_SUPPORT
-#include "gc2145.h"
-#endif
-#if CONFIG_GC032A_SUPPORT
-#include "gc032a.h"
-#endif
-#if CONFIG_GC0308_SUPPORT
-#include "gc0308.h"
-#endif
-#if CONFIG_BF3005_SUPPORT
-#include "bf3005.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 = "camera";
-#endif
-
-typedef struct {
-    sensor_t sensor;
-    camera_fb_t fb;
-} camera_state_t;
-
-static const char *CAMERA_SENSOR_NVS_KEY = "sensor";
-static const char *CAMERA_PIXFORMAT_NVS_KEY = "pixformat";
-static camera_state_t *s_state = NULL;
-
-#if CONFIG_IDF_TARGET_ESP32S3 // LCD_CAM module of ESP32-S3 will generate xclk
-#define CAMERA_ENABLE_OUT_CLOCK(v)
-#define CAMERA_DISABLE_OUT_CLOCK()
-#else
-#define CAMERA_ENABLE_OUT_CLOCK(v) camera_enable_out_clock((v))
-#define CAMERA_DISABLE_OUT_CLOCK() camera_disable_out_clock()
-#endif
-
-typedef struct {
-    int (*detect)(int slv_addr, sensor_id_t *id);
-    int (*init)(sensor_t *sensor);
-} sensor_func_t;
-
-static const sensor_func_t g_sensors[] = {
-#if CONFIG_OV7725_SUPPORT
-    {ov7725_detect, ov7725_init},
-#endif
-#if CONFIG_OV7670_SUPPORT
-    {ov7670_detect, ov7670_init},
-#endif
-#if CONFIG_OV2640_SUPPORT
-    {ov2640_detect, ov2640_init},
-#endif
-#if CONFIG_OV3660_SUPPORT
-    {ov3660_detect, ov3660_init},
-#endif
-#if CONFIG_OV5640_SUPPORT
-    {ov5640_detect, ov5640_init},
-#endif
-#if CONFIG_NT99141_SUPPORT
-    {nt99141_detect, nt99141_init},
-#endif
-#if CONFIG_GC2145_SUPPORT
-    {gc2145_detect, gc2145_init},
-#endif
-#if CONFIG_GC032A_SUPPORT
-    {gc032a_detect, gc032a_init},
-#endif
-#if CONFIG_GC0308_SUPPORT
-    {gc0308_detect, gc0308_init},
-#endif
-#if CONFIG_BF3005_SUPPORT
-    {bf3005_detect, bf3005_init},
-#endif
-};
-
-static esp_err_t camera_probe(const camera_config_t *config, camera_model_t *out_camera_model)
-{
-    *out_camera_model = CAMERA_NONE;
-    if (s_state != NULL) {
-        return ESP_ERR_INVALID_STATE;
-    }
-
-    s_state = (camera_state_t *) calloc(sizeof(camera_state_t), 1);
-    if (!s_state) {
-        return ESP_ERR_NO_MEM;
-    }
-
-    if (config->pin_xclk >= 0) {
-        ESP_LOGD(TAG, "Enabling XCLK output");
-        CAMERA_ENABLE_OUT_CLOCK(config);
-    }
-
-    if (config->pin_sscb_sda != -1) {
-        ESP_LOGD(TAG, "Initializing SSCB");
-        SCCB_Init(config->pin_sscb_sda, config->pin_sscb_scl);
-    }
-
-    if (config->pin_pwdn >= 0) {
-        ESP_LOGD(TAG, "Resetting camera by power down line");
-        gpio_config_t conf = { 0 };
-        conf.pin_bit_mask = 1LL << config->pin_pwdn;
-        conf.mode = GPIO_MODE_OUTPUT;
-        gpio_config(&conf);
-
-        // carefull, logic is inverted compared to reset pin
-        gpio_set_level(config->pin_pwdn, 1);
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-        gpio_set_level(config->pin_pwdn, 0);
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-    }
-
-    if (config->pin_reset >= 0) {
-        ESP_LOGD(TAG, "Resetting camera");
-        gpio_config_t conf = { 0 };
-        conf.pin_bit_mask = 1LL << config->pin_reset;
-        conf.mode = GPIO_MODE_OUTPUT;
-        gpio_config(&conf);
-
-        gpio_set_level(config->pin_reset, 0);
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-        gpio_set_level(config->pin_reset, 1);
-        vTaskDelay(10 / portTICK_PERIOD_MS);
-    }
-
-
-    ESP_LOGD(TAG, "Searching for camera address");
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-
-    uint8_t slv_addr = SCCB_Probe();
-
-    if (slv_addr == 0) {
-        CAMERA_DISABLE_OUT_CLOCK();
-        return ESP_ERR_NOT_FOUND;
-    }
-
-    ESP_LOGI(TAG, "Detected camera at address=0x%02x", slv_addr);
-    s_state->sensor.slv_addr = slv_addr;
-    s_state->sensor.xclk_freq_hz = config->xclk_freq_hz;
-
-    /**
-     * Read sensor ID and then initialize sensor
-     * Attention: Some sensors have the same SCCB address. Therefore, several attempts may be made in the detection process
-     */
-    sensor_id_t *id = &s_state->sensor.id;
-    for (size_t i = 0; i < sizeof(g_sensors) / sizeof(sensor_func_t); i++) {
-        if (g_sensors[i].detect(slv_addr, id)) {
-            camera_sensor_info_t *info = esp_camera_sensor_get_info(id);
-            if (NULL != info) {
-                *out_camera_model = info->model;
-                ESP_LOGI(TAG, "Detected %s camera", info->name);
-                g_sensors[i].init(&s_state->sensor);
-                break;
-            }
-        }
-    }
-
-    if (CAMERA_NONE == *out_camera_model) { //If no supported sensors are detected
-        CAMERA_DISABLE_OUT_CLOCK();
-        ESP_LOGE(TAG, "Detected camera not supported.");
-        return ESP_ERR_NOT_SUPPORTED;
-    }
-
-    ESP_LOGI(TAG, "Camera PID=0x%02x VER=0x%02x MIDL=0x%02x MIDH=0x%02x",
-             id->PID, id->VER, id->MIDH, id->MIDL);
-
-    ESP_LOGD(TAG, "Doing SW reset of sensor");
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-    s_state->sensor.reset(&s_state->sensor);
-
-    return ESP_OK;
-}
-
-esp_err_t esp_camera_init(const camera_config_t *config)
-{
-    esp_err_t err;
-    err = cam_init(config);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "Camera init failed with error 0x%x", err);
-        return err;
-    }
-
-    camera_model_t camera_model = CAMERA_NONE;
-    err = camera_probe(config, &camera_model);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "Camera probe failed with error 0x%x(%s)", err, esp_err_to_name(err));
-        goto fail;
-    }
-
-    framesize_t frame_size = (framesize_t) config->frame_size;
-    pixformat_t pix_format = (pixformat_t) config->pixel_format;
-
-    if (PIXFORMAT_JPEG == pix_format && (!camera_sensor[camera_model].support_jpeg)) {
-        ESP_LOGE(TAG, "JPEG format is not supported on this sensor");
-        err = ESP_ERR_NOT_SUPPORTED;
-        goto fail;
-    }
-
-    if (frame_size > camera_sensor[camera_model].max_size) {
-        ESP_LOGW(TAG, "The frame size exceeds the maximum for this sensor, it will be forced to the maximum possible value");
-        frame_size = camera_sensor[camera_model].max_size;
-    }
-
-    err = cam_config(config, frame_size, s_state->sensor.id.PID);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "Camera config failed with error 0x%x", err);
-        goto fail;
-    }
-
-    s_state->sensor.status.framesize = frame_size;
-    s_state->sensor.pixformat = pix_format;
-    ESP_LOGD(TAG, "Setting frame size to %dx%d", resolution[frame_size].width, resolution[frame_size].height);
-    if (s_state->sensor.set_framesize(&s_state->sensor, frame_size) != 0) {
-        ESP_LOGE(TAG, "Failed to set frame size");
-        err = ESP_ERR_CAMERA_FAILED_TO_SET_FRAME_SIZE;
-        goto fail;
-    }
-    s_state->sensor.set_pixformat(&s_state->sensor, pix_format);
-
-    if (s_state->sensor.id.PID == OV2640_PID) {
-        s_state->sensor.set_gainceiling(&s_state->sensor, GAINCEILING_2X);
-        s_state->sensor.set_bpc(&s_state->sensor, false);
-        s_state->sensor.set_wpc(&s_state->sensor, true);
-        s_state->sensor.set_lenc(&s_state->sensor, true);
-    }
-
-    if (pix_format == PIXFORMAT_JPEG) {
-        s_state->sensor.set_quality(&s_state->sensor, config->jpeg_quality);
-    }
-    s_state->sensor.init_status(&s_state->sensor);
-
-    cam_start();
-
-    return ESP_OK;
-
-fail:
-    esp_camera_deinit();
-    return err;
-}
-
-esp_err_t esp_camera_deinit()
-{
-    esp_err_t ret = cam_deinit();
-    CAMERA_DISABLE_OUT_CLOCK();
-    if (s_state) {
-        SCCB_Deinit();
-
-        free(s_state);
-        s_state = NULL;
-    }
-
-    return ret;
-}
-
-#define FB_GET_TIMEOUT (4000 / portTICK_PERIOD_MS)
-
-camera_fb_t *esp_camera_fb_get()
-{
-    if (s_state == NULL) {
-        return NULL;
-    }
-    camera_fb_t *fb = cam_take(FB_GET_TIMEOUT);
-    //set the frame properties
-    if (fb) {
-        fb->width = resolution[s_state->sensor.status.framesize].width;
-        fb->height = resolution[s_state->sensor.status.framesize].height;
-        fb->format = s_state->sensor.pixformat;
-    }
-    return fb;
-}
-
-void esp_camera_fb_return(camera_fb_t *fb)
-{
-    if (s_state == NULL) {
-        return;
-    }
-    cam_give(fb);
-}
-
-sensor_t *esp_camera_sensor_get()
-{
-    if (s_state == NULL) {
-        return NULL;
-    }
-    return &s_state->sensor;
-}
-
-esp_err_t esp_camera_save_to_nvs(const char *key)
-{
-#if ESP_IDF_VERSION_MAJOR > 3
-    nvs_handle_t handle;
-#else
-    nvs_handle handle;
-#endif
-    esp_err_t ret = nvs_open(key, NVS_READWRITE, &handle);
-
-    if (ret == ESP_OK) {
-        sensor_t *s = esp_camera_sensor_get();
-        if (s != NULL) {
-            ret = nvs_set_blob(handle, CAMERA_SENSOR_NVS_KEY, &s->status, sizeof(camera_status_t));
-            if (ret == ESP_OK) {
-                uint8_t pf = s->pixformat;
-                ret = nvs_set_u8(handle, CAMERA_PIXFORMAT_NVS_KEY, pf);
-            }
-            return ret;
-        } else {
-            return ESP_ERR_CAMERA_NOT_DETECTED;
-        }
-        nvs_close(handle);
-        return ret;
-    } else {
-        return ret;
-    }
-}
-
-esp_err_t esp_camera_load_from_nvs(const char *key)
-{
-#if ESP_IDF_VERSION_MAJOR > 3
-    nvs_handle_t handle;
-#else
-    nvs_handle handle;
-#endif
-    uint8_t pf;
-
-    esp_err_t ret = nvs_open(key, NVS_READWRITE, &handle);
-
-    if (ret == ESP_OK) {
-        sensor_t *s = esp_camera_sensor_get();
-        camera_status_t st;
-        if (s != NULL) {
-            size_t size = sizeof(camera_status_t);
-            ret = nvs_get_blob(handle, CAMERA_SENSOR_NVS_KEY, &st, &size);
-            if (ret == ESP_OK) {
-                s->set_ae_level(s, st.ae_level);
-                s->set_aec2(s, st.aec2);
-                s->set_aec_value(s, st.aec_value);
-                s->set_agc_gain(s, st.agc_gain);
-                s->set_awb_gain(s, st.awb_gain);
-                s->set_bpc(s, st.bpc);
-                s->set_brightness(s, st.brightness);
-                s->set_colorbar(s, st.colorbar);
-                s->set_contrast(s, st.contrast);
-                s->set_dcw(s, st.dcw);
-                s->set_denoise(s, st.denoise);
-                s->set_exposure_ctrl(s, st.aec);
-                s->set_framesize(s, st.framesize);
-                s->set_gain_ctrl(s, st.agc);
-                s->set_gainceiling(s, st.gainceiling);
-                s->set_hmirror(s, st.hmirror);
-                s->set_lenc(s, st.lenc);
-                s->set_quality(s, st.quality);
-                s->set_raw_gma(s, st.raw_gma);
-                s->set_saturation(s, st.saturation);
-                s->set_sharpness(s, st.sharpness);
-                s->set_special_effect(s, st.special_effect);
-                s->set_vflip(s, st.vflip);
-                s->set_wb_mode(s, st.wb_mode);
-                s->set_whitebal(s, st.awb);
-                s->set_wpc(s, st.wpc);
-            }
-            ret = nvs_get_u8(handle, CAMERA_PIXFORMAT_NVS_KEY, &pf);
-            if (ret == ESP_OK) {
-                s->set_pixformat(s, pf);
-            }
-        } else {
-            return ESP_ERR_CAMERA_NOT_DETECTED;
-        }
-        nvs_close(handle);
-        return ret;
-    } else {
-        ESP_LOGW(TAG, "Error (%d) opening nvs key \"%s\"", ret, key);
-        return ret;
-    }
-}

code/components/esp32-camera-master/driver/include/esp_camera.h

@@ -1,214 +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,
-        .grab_mode      = CAMERA_GRAB_WHEN_EMPTY
-    };
-
-    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 enum {
-    CAMERA_GRAB_WHEN_EMPTY,         /*!< Fills buffers when they are empty. Less resources but first 'fb_count' frames might be old */
-    CAMERA_GRAB_LATEST              /*!< Except when 1 frame buffer is used, queue will always contain the last 'fb_count' frames */
-} camera_grab_mode_t;
-
-/**
- * @brief Camera frame buffer location 
- */
-typedef enum {
-    CAMERA_FB_IN_PSRAM,         /*!< Frame buffer is placed in external PSRAM */
-    CAMERA_FB_IN_DRAM           /*!< Frame buffer is placed in internal DRAM */
-} camera_fb_location_t;
-
-/**
- * @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. EXPERIMENTAL: Set to 16MHz on ESP32-S2 or ESP32-S3 to enable EDMA mode */
-
-    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_fb_location_t fb_location; /*!< The location where the frame buffer will be allocated */
-    camera_grab_mode_t grab_mode;   /*!< When buffers should be filled */
-} 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"
-

code/components/esp32-camera-master/driver/include/sensor.h

@@ -1,248 +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,
-    BF3005_PID = 0x30,
-} camera_pid_t;
-
-typedef enum {
-    CAMERA_OV7725,
-    CAMERA_OV2640,
-    CAMERA_OV3660,
-    CAMERA_OV5640,
-    CAMERA_OV7670,
-    CAMERA_NT99141,
-    CAMERA_GC2145,
-    CAMERA_GC032A,
-    CAMERA_GC0308,
-    CAMERA_BF3005,
-    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
-    BF3005_SCCB_ADDR   = 0x6E,
-} 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__ */

code/components/esp32-camera-master/driver/private_include/cam_hal.h

@@ -1,60 +0,0 @@
-// Copyright 2010-2020 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.
-
-#pragma once
-
-#include "esp_camera.h"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @brief Uninitialize the lcd_cam module
- *
- * @param handle Provide handle pointer to release resources
- *
- * @return
- *     - ESP_OK Success
- *     - ESP_FAIL Uninitialize fail
- */
-esp_err_t cam_deinit(void);
-
-/**
- * @brief Initialize the lcd_cam module
- *
- * @param config Configurations - see lcd_cam_config_t struct
- *
- * @return
- *     - ESP_OK Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM No memory to initialize lcd_cam
- *     - ESP_FAIL Initialize fail
- */
-esp_err_t cam_init(const camera_config_t *config);
-
-esp_err_t cam_config(const camera_config_t *config, framesize_t frame_size, uint16_t sensor_pid);
-
-void cam_stop(void);
-
-void cam_start(void);
-
-camera_fb_t *cam_take(TickType_t timeout);
-
-void cam_give(camera_fb_t *dma_buffer);
-
-#ifdef __cplusplus
-}
-#endif

code/components/esp32-camera-master/driver/private_include/sccb.h

@@ -1,19 +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);
-int SCCB_Deinit(void);
-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__

code/components/esp32-camera-master/driver/private_include/xclk.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include "esp_system.h"
-
-esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz);
-
-esp_err_t camera_enable_out_clock();
-
-void camera_disable_out_clock();

code/components/esp32-camera-master/driver/sccb.c

@@ -1,184 +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 "sensor.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               CONFIG_SCCB_CLK_FREQ  /*!< 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
-
-int SCCB_Init(int pin_sda, int pin_scl)
-{
-    ESP_LOGI(TAG, "pin_sda %d pin_scl %d", pin_sda, pin_scl);
-    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;
-}
-
-int SCCB_Deinit(void)
-{
-    return i2c_driver_delete(SCCB_I2C_PORT);
-}
-
-uint8_t SCCB_Probe(void)
-{
-    uint8_t slave_addr = 0x0;
-    // for (size_t i = 1; i < 0x80; i++) {
-    //     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    //     i2c_master_start(cmd);
-    //     i2c_master_write_byte(cmd, ( i << 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_LOGW(TAG, "Found I2C Device at 0x%02X", i);
-    //     }
-    // }
-    for (size_t i = 0; i < CAMERA_MODEL_MAX; i++) {
-        if (slave_addr == camera_sensor[i].sccb_addr) {
-            continue;
-        }
-        slave_addr = camera_sensor[i].sccb_addr;
-        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) {
-            return slave_addr;
-        }
-    }
-    return 0;
-}
-
-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;
-}

code/components/esp32-camera-master/driver/sensor.c

@@ -1,53 +0,0 @@
-#include <stdio.h>
-#include "sensor.h"
-
-const camera_sensor_info_t camera_sensor[CAMERA_MODEL_MAX] = {
-    // The sequence must be consistent with camera_model_t
-    {CAMERA_OV7725, "OV7725", OV7725_SCCB_ADDR, OV7725_PID, FRAMESIZE_VGA, false},
-    {CAMERA_OV2640, "OV2640", OV2640_SCCB_ADDR, OV2640_PID, FRAMESIZE_UXGA, true},
-    {CAMERA_OV3660, "OV3660", OV3660_SCCB_ADDR, OV3660_PID, FRAMESIZE_QXGA, true},
-    {CAMERA_OV5640, "OV5640", OV5640_SCCB_ADDR, OV5640_PID, FRAMESIZE_QSXGA, true},
-    {CAMERA_OV7670, "OV7670", OV7670_SCCB_ADDR, OV7670_PID, FRAMESIZE_VGA, false},
-    {CAMERA_NT99141, "NT99141", NT99141_SCCB_ADDR, NT99141_PID, FRAMESIZE_HD, true},
-    {CAMERA_GC2145, "GC2145", GC2145_SCCB_ADDR, GC2145_PID, FRAMESIZE_UXGA, false},
-    {CAMERA_GC032A, "GC032A", GC032A_SCCB_ADDR, GC032A_PID, FRAMESIZE_VGA, false},
-    {CAMERA_GC0308, "GC0308", GC0308_SCCB_ADDR, GC0308_PID, FRAMESIZE_VGA, false},
-    {CAMERA_BF3005, "BF3005", BF3005_SCCB_ADDR, BF3005_PID, FRAMESIZE_VGA, false},
-};
-
-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  */
-};
-
-camera_sensor_info_t *esp_camera_sensor_get_info(sensor_id_t *id)
-{
-    for (int i = 0; i < CAMERA_MODEL_MAX; i++) {
-        if (id->PID == camera_sensor[i].pid) {
-            return (camera_sensor_info_t *)&camera_sensor[i];
-        }
-    }
-    return NULL;
-}

code/components/esp32-camera-master/examples/CMakeLists.txt

@@ -1,9 +0,0 @@
-# The following lines of boilerplate have to be in your project's
-# CMakeLists in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
-
-set(EXTRA_COMPONENT_DIRS "../")
-
-add_compile_options(-fdiagnostics-color=always)
-include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(camera_example)

code/components/esp32-camera-master/examples/main/CMakeLists.txt

@@ -1,3 +0,0 @@
-set(COMPONENT_SRCS take_picture.c)
-set(COMPONENT_ADD_INCLUDEDIRS .)
-register_component()

code/components/esp32-camera-master/examples/main/component.mk

@@ -1,5 +0,0 @@
-#
-# "main" pseudo-component makefile.
-#
-# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
-

code/components/esp32-camera-master/examples/main/take_picture.c

@@ -1,155 +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_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"
-
-#define BOARD_WROVER_KIT 1
-
-// 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_RGB565, //YUV422,GRAYSCALE,RGB565,JPEG
-    .frame_size = FRAMESIZE_QVGA,    //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
-    .grab_mode = CAMERA_GRAB_WHEN_EMPTY,
-};
-
-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()
-{
-    if(ESP_OK != init_camera()) {
-        return;
-    }
-
-    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);
-        esp_camera_fb_return(pic);
-
-        vTaskDelay(5000 / portTICK_RATE_MS);
-    }
-}

code/components/esp32-camera-master/examples/sdkconfig.defaults

@@ -1,17 +0,0 @@
-CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
-CONFIG_ESP32S2_DEFAULT_CPU_FREQ_240=y
-CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
-
-CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
-CONFIG_PARTITION_TABLE_OFFSET=0x10000
-
-CONFIG_FREERTOS_HZ=1000
-CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
-CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
-
-CONFIG_SPIRAM_SUPPORT=y
-CONFIG_ESP32_SPIRAM_SUPPORT=y
-CONFIG_ESP32S2_SPIRAM_SUPPORT=y
-CONFIG_ESP32S3_SPIRAM_SUPPORT=y
-CONFIG_SPIRAM_SPEED_80M=y
-

code/components/esp32-camera-master/idf_component.yml

@@ -1,5 +0,0 @@
-description: ESP32 compatible driver for OV2640, OV3660, OV5640, OV7670 and OV7725 image sensors.
-targets:
-  - esp32
-  - esp32s2
-  - esp32s3