Apply further clang formatting.

README.md

@@ -169,6 +169,12 @@ by [Dave Lee][github-profile-leedave].
 4. Request PR [here][pull-request-link], introduce work via your branch.
 5. Wait for review and merge. Thank you!
 
+For C development you will need the [clang format tool][clang-format-tool] for linting/formatting.
+
+```json
+FOR /R C:\path-to-repo\Flipper-Zero-Camera-Suite\ %F IN (*.h *.ino *.c *.cpp) DO clang-format -i "%F"
+```
+
 <p align="right">[ <a href="#index">Back to top</a> ]</p>
 
 Fin. Thanks for looking and happy programming friend!
@@ -180,6 +186,7 @@ Cody
 [amazon-esp32-cam-link-1]: https://amzn.to/44rBFrb
 [amazon-esp32-cam-link-2]: https://amzn.to/45nDR45
 [arduino-ide]: https://www.arduino.cc/en/software
+[clang-format-tool]: https://releases.llvm.org/download.html
 [flipper-zero-camera-suite-releases]: https://github.com/CodyTolene/Flipper-Zero-Camera-Suite/releases
 [flipper-zero-fap-boilerplate]: https://github.com/leedave/flipper-zero-fap-boilerplate
 [flipperzero-camera]: https://github.com/Z4urce/flipperzero-camera

firmware-update/camera_model.h

@@ -13,8 +13,8 @@ enum DitheringAlgorithm : uint8_t {
 };
 
 class CameraModel {
-   private:
-    static CameraModel *instance;
+  private:
+    static CameraModel* instance;
     // Private constructor to prevent instantiation.
     CameraModel();
     /**
@@ -38,8 +38,8 @@ class CameraModel {
      */
     DitheringAlgorithm ditherAlgorithm;
 
-   public:
-    static CameraModel *getInstance();
+  public:
+    static CameraModel* getInstance();
 
     // Getter functions
     bool getIsDitheringDisabled();

firmware-update/camera_model.ino

@@ -1,6 +1,6 @@
 #include "camera_model.h"
 
-CameraModel *CameraModel::instance = nullptr;
+CameraModel* CameraModel::instance = nullptr;
 
 CameraModel::CameraModel() {
     // Set up defaults.
@@ -11,7 +11,7 @@ CameraModel::CameraModel() {
     ditherAlgorithm = FLOYD_STEINBERG;
 }
 
-CameraModel *CameraModel::getInstance() {
+CameraModel* CameraModel::getInstance() {
     if (instance == nullptr) {
         instance = new CameraModel();
     }

firmware-update/dithering.h

@@ -5,6 +5,6 @@
 
 #include "camera_model.h"
 
-void dither_image(camera_fb_t *frame_buffer);
+void dither_image(camera_fb_t* frame_buffer);
 
 #endif

firmware-update/dithering.ino

@@ -14,71 +14,71 @@ void dither_image(camera_fb_t* frame_buffer) {
 
             // Apply error diffusion based on the selected algorithm
             switch (model->getDitherAlgorithm()) {
-                case JARVIS_JUDICE_NINKE:
-                    frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
-                        quant_error * 7 / 48;
-                    frame_buffer->buf[(y * frame_buffer->width) + x + 2] +=
-                        quant_error * 5 / 48;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x - 2] +=
-                        quant_error * 3 / 48;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
-                        quant_error * 5 / 48;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
-                        quant_error * 7 / 48;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
-                        quant_error * 5 / 48;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x + 2] +=
-                        quant_error * 3 / 48;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x - 2] +=
-                        quant_error * 1 / 48;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x - 1] +=
-                        quant_error * 3 / 48;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x] +=
-                        quant_error * 5 / 48;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x + 1] +=
-                        quant_error * 3 / 48;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x + 2] +=
-                        quant_error * 1 / 48;
-                    break;
-                case STUCKI:
-                    frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
-                        quant_error * 8 / 42;
-                    frame_buffer->buf[(y * frame_buffer->width) + x + 2] +=
-                        quant_error * 4 / 42;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x - 2] +=
-                        quant_error * 2 / 42;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
-                        quant_error * 4 / 42;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
-                        quant_error * 8 / 42;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
-                        quant_error * 4 / 42;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x + 2] +=
-                        quant_error * 2 / 42;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x - 2] +=
-                        quant_error * 1 / 42;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x - 1] +=
-                        quant_error * 2 / 42;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x] +=
-                        quant_error * 4 / 42;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x + 1] +=
-                        quant_error * 2 / 42;
-                    frame_buffer->buf[(y + 2) * frame_buffer->width + x + 2] +=
-                        quant_error * 1 / 42;
-                    break;
-                case FLOYD_STEINBERG:
-                default:
-                    // Default to Floyd-Steinberg dithering if an invalid
-                    // algorithm is selected
-                    frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
-                        quant_error * 7 / 16;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
-                        quant_error * 3 / 16;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
-                        quant_error * 5 / 16;
-                    frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
-                        quant_error * 1 / 16;
-                    break;
+            case JARVIS_JUDICE_NINKE:
+                frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
+                    quant_error * 7 / 48;
+                frame_buffer->buf[(y * frame_buffer->width) + x + 2] +=
+                    quant_error * 5 / 48;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x - 2] +=
+                    quant_error * 3 / 48;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
+                    quant_error * 5 / 48;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
+                    quant_error * 7 / 48;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
+                    quant_error * 5 / 48;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x + 2] +=
+                    quant_error * 3 / 48;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x - 2] +=
+                    quant_error * 1 / 48;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x - 1] +=
+                    quant_error * 3 / 48;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x] +=
+                    quant_error * 5 / 48;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x + 1] +=
+                    quant_error * 3 / 48;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x + 2] +=
+                    quant_error * 1 / 48;
+                break;
+            case STUCKI:
+                frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
+                    quant_error * 8 / 42;
+                frame_buffer->buf[(y * frame_buffer->width) + x + 2] +=
+                    quant_error * 4 / 42;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x - 2] +=
+                    quant_error * 2 / 42;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
+                    quant_error * 4 / 42;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
+                    quant_error * 8 / 42;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
+                    quant_error * 4 / 42;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x + 2] +=
+                    quant_error * 2 / 42;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x - 2] +=
+                    quant_error * 1 / 42;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x - 1] +=
+                    quant_error * 2 / 42;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x] +=
+                    quant_error * 4 / 42;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x + 1] +=
+                    quant_error * 2 / 42;
+                frame_buffer->buf[(y + 2) * frame_buffer->width + x + 2] +=
+                    quant_error * 1 / 42;
+                break;
+            case FLOYD_STEINBERG:
+            default:
+                // Default to Floyd-Steinberg dithering if an invalid
+                // algorithm is selected
+                frame_buffer->buf[(y * frame_buffer->width) + x + 1] +=
+                    quant_error * 7 / 16;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x - 1] +=
+                    quant_error * 3 / 16;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x] +=
+                    quant_error * 5 / 16;
+                frame_buffer->buf[(y + 1) * frame_buffer->width + x + 1] +=
+                    quant_error * 1 / 16;
+                break;
             }
         }
     }

firmware-update/firmware.ino

@@ -10,7 +10,7 @@ camera_config_t config;
 // Entry point of the program.
 void setup() {
     // Set up the camera model.
-    CameraModel *model = CameraModel::getInstance();
+    CameraModel* model = CameraModel::getInstance();
 
     // Set up the model defaults.
     model->setIsDitheringDisabled(false);
@@ -44,7 +44,7 @@ void setup() {
     config.fb_count = 1;
 
     // Begin serial communication.
-    Serial.begin(230400);  // 115200
+    Serial.begin(230400); // 115200
 
     // Initialize the camera.
     initialize(&config);
@@ -53,9 +53,9 @@ void setup() {
 // Main loop of the program.
 void loop() {
     // Get the camera model reference.
-    CameraModel *model = CameraModel::getInstance();
+    CameraModel* model = CameraModel::getInstance();
     if (model->getIsStreamEnabled()) {
-        camera_fb_t *frame_buffer = esp_camera_fb_get();
+        camera_fb_t* frame_buffer = esp_camera_fb_get();
         if (frame_buffer) {
             process_image(frame_buffer);
             // Return the frame buffer back to the camera driver.

firmware-update/initialize.h

@@ -7,6 +7,6 @@
 #include "camera_model.h"
 #include "pins.h"
 
-void initialize(camera_config_t *config);
+void initialize(camera_config_t* config);
 
 #endif

firmware-update/initialize.ino

@@ -1,6 +1,6 @@
 #include "initialize.h"
 
-void initialize(camera_config_t *config) {
+void initialize(camera_config_t* config) {
     // Initialize camera.
     esp_err_t err = esp_camera_init(config);
     if (err != ESP_OK) {
@@ -8,7 +8,7 @@ void initialize(camera_config_t *config) {
     }
 
     // Get the camera model reference.
-    CameraModel *model = CameraModel::getInstance();
+    CameraModel* model = CameraModel::getInstance();
 
     // Check if the flash is already on, if it is turn it off.
     if (model->getIsFlashEnabled()) {
@@ -18,10 +18,10 @@ void initialize(camera_config_t *config) {
     }
 
     // Get the camera sensor reference.
-    sensor_t *cam = esp_camera_sensor_get();
+    sensor_t* cam = esp_camera_sensor_get();
 
     // Set up the frame buffer reference.
-    camera_fb_t *frame_buffer = esp_camera_fb_get();
+    camera_fb_t* frame_buffer = esp_camera_fb_get();
 
     // Set initial brightness.
     cam->set_brightness(cam, 0);

firmware-update/process_image.h

@@ -8,6 +8,6 @@
 #include "dithering.h"
 
 /** Process and send grayscale images back to the Flipper Zero. */
-void process_image(camera_fb_t *frame_buffer);
+void process_image(camera_fb_t* frame_buffer);
 
 #endif

firmware-update/process_image.ino

@@ -1,24 +1,24 @@
 #include "process_image.h"
 
-void process_image(camera_fb_t *frame_buffer) {
+void process_image(camera_fb_t* frame_buffer) {
     // Get the camera model reference.
-    CameraModel *model = CameraModel::getInstance();
+    CameraModel* model = CameraModel::getInstance();
 
     // If dithering is not disabled, perform dithering on the image. Dithering
     // is the process of approximating the look of a high-resolution grayscale
     // image in a lower resolution by binary values (black & white), thereby
     // representing different shades of gray.
     if (!model->getIsDitheringDisabled()) {
-        dither_image(frame_buffer);  // Invokes the dithering process on the
-                                     // frame buffer.
+        dither_image(frame_buffer); // Invokes the dithering process on the
+                                    // frame buffer.
     }
 
     uint8_t flipper_y = 0;
 
     // Iterating over specific rows of the frame buffer.
     for (uint8_t y = 28; y < 92; ++y) {
-        Serial.print("Y:");       // Print "Y:" for every new row.
-        Serial.write(flipper_y);  // Send the row identifier as a byte.
+        Serial.print("Y:");      // Print "Y:" for every new row.
+        Serial.write(flipper_y); // Send the row identifier as a byte.
 
         // Calculate the actual y index in the frame buffer 1D array by
         // multiplying the y value with the width of the frame buffer. This
@@ -27,7 +27,7 @@ void process_image(camera_fb_t *frame_buffer) {
 
         // Iterating over specific columns of each row in the frame buffer.
         for (uint8_t x = 16; x < 144;
-             x += 8) {  // step by 8 as we're packing 8 pixels per byte.
+             x += 8) { // step by 8 as we're packing 8 pixels per byte.
             uint8_t packed_pixels = 0;
             // Packing 8 pixel values into one byte.
             for (uint8_t bit = 0; bit < 8; ++bit) {
@@ -46,11 +46,11 @@ void process_image(camera_fb_t *frame_buffer) {
                     }
                 }
             }
-            Serial.write(packed_pixels);  // Sending packed pixel byte.
+            Serial.write(packed_pixels); // Sending packed pixel byte.
         }
 
-        ++flipper_y;     // Move to the next row.
-        Serial.flush();  // Ensure all data in the Serial buffer is sent before
-                         // moving to the next iteration.
+        ++flipper_y;    // Move to the next row.
+        Serial.flush(); // Ensure all data in the Serial buffer is sent before
+                        // moving to the next iteration.
     }
 }

firmware-update/save_picture.ino

@@ -1,7 +1,7 @@
 #include "save_picture.h"
 
 void save_picture() {
-    sensor_t *cam = esp_camera_sensor_get();
+    sensor_t* cam = esp_camera_sensor_get();
 
     // Check if the sensor is valid.
     if (!cam) {
@@ -20,7 +20,7 @@ void save_picture() {
     }
 
     // Get a frame buffer from camera.
-    camera_fb_t *frame_buffer = esp_camera_fb_get();
+    camera_fb_t* frame_buffer = esp_camera_fb_get();
     if (!frame_buffer) {
         // Camera capture failed
         return;
@@ -37,7 +37,7 @@ void save_picture() {
     path += String(millis());
     path += ".jpg";
 
-    fs::FS &fs = SD_MMC;
+    fs::FS& fs = SD_MMC;
     File file = fs.open(path.c_str(), FILE_WRITE);
 
     if (!file) {
@@ -47,7 +47,7 @@ void save_picture() {
             frame_buffer->len) {
             // Failed to write the image to the file
         }
-        file.close();  // Close the file in any case.
+        file.close(); // Close the file in any case.
     }
 
     // Update framesize back to the default.

firmware-update/serial_commands.ino

@@ -3,65 +3,65 @@
 void serial_commands() {
     if (Serial.available() > 0) {
         // Get the camera model reference.
-        CameraModel *model = CameraModel::getInstance();
+        CameraModel* model = CameraModel::getInstance();
 
         char input = Serial.read();
-        sensor_t *cam = esp_camera_sensor_get();
+        sensor_t* cam = esp_camera_sensor_get();
 
         switch (input) {
-            case '>':  // Toggle dithering.
-                model->setIsDitheringDisabled(!model->getIsDitheringDisabled());
-                break;
-            case '<':  // Toggle invert.
-                model->setIsInverted(!model->getIsInverted());
-                break;
-            case 'b':  // Remove brightness.
-                cam->set_contrast(cam, cam->status.brightness - 1);
-                break;
-            case 'B':  // Add brightness.
-                cam->set_contrast(cam, cam->status.brightness + 1);
-                break;
-            case 'c':  // Remove contrast.
-                cam->set_contrast(cam, cam->status.contrast - 1);
-                break;
-            case 'C':  // Add contrast.
-                cam->set_contrast(cam, cam->status.contrast + 1);
-                break;
-            case 'f':  // Turn the flash off.
-                pinMode(FLASH_GPIO_NUM, OUTPUT);
-                digitalWrite(FLASH_GPIO_NUM, LOW);
-                model->setIsFlashEnabled(false);
-                break;
-            case 'F':  // Turn the flash on.
-                pinMode(FLASH_GPIO_NUM, OUTPUT);
-                digitalWrite(FLASH_GPIO_NUM, HIGH);
-                model->setIsFlashEnabled(true);
-                break;
-            case 'P':  // Save image to the onboard SD card.
-                // @todo - Future feature.
-                // save_picture();
-                break;
-            case 'M':  // Toggle Mirror.
-                cam->set_hmirror(cam, !cam->status.hmirror);
-                break;
-            case 's':  // Stop stream.
-                model->setIsStreamEnabled(false);
-                break;
-            case 'S':  // Start stream.
-                model->setIsStreamEnabled(true);
-                break;
-            case '0':  // Use Floyd Steinberg dithering.
-                model->setDitherAlgorithm(FLOYD_STEINBERG);
-                break;
-            case '1':  // Use Jarvis Judice dithering.
-                model->setDitherAlgorithm(JARVIS_JUDICE_NINKE);
-                break;
-            case '2':  // Use Stucki dithering.
-                model->setDitherAlgorithm(STUCKI);
-                break;
-            default:
-                // Do nothing.
-                break;
+        case '>': // Toggle dithering.
+            model->setIsDitheringDisabled(!model->getIsDitheringDisabled());
+            break;
+        case '<': // Toggle invert.
+            model->setIsInverted(!model->getIsInverted());
+            break;
+        case 'b': // Remove brightness.
+            cam->set_contrast(cam, cam->status.brightness - 1);
+            break;
+        case 'B': // Add brightness.
+            cam->set_contrast(cam, cam->status.brightness + 1);
+            break;
+        case 'c': // Remove contrast.
+            cam->set_contrast(cam, cam->status.contrast - 1);
+            break;
+        case 'C': // Add contrast.
+            cam->set_contrast(cam, cam->status.contrast + 1);
+            break;
+        case 'f': // Turn the flash off.
+            pinMode(FLASH_GPIO_NUM, OUTPUT);
+            digitalWrite(FLASH_GPIO_NUM, LOW);
+            model->setIsFlashEnabled(false);
+            break;
+        case 'F': // Turn the flash on.
+            pinMode(FLASH_GPIO_NUM, OUTPUT);
+            digitalWrite(FLASH_GPIO_NUM, HIGH);
+            model->setIsFlashEnabled(true);
+            break;
+        case 'P': // Save image to the onboard SD card.
+            // @todo - Future feature.
+            // save_picture();
+            break;
+        case 'M': // Toggle Mirror.
+            cam->set_hmirror(cam, !cam->status.hmirror);
+            break;
+        case 's': // Stop stream.
+            model->setIsStreamEnabled(false);
+            break;
+        case 'S': // Start stream.
+            model->setIsStreamEnabled(true);
+            break;
+        case '0': // Use Floyd Steinberg dithering.
+            model->setDitherAlgorithm(FLOYD_STEINBERG);
+            break;
+        case '1': // Use Jarvis Judice dithering.
+            model->setDitherAlgorithm(JARVIS_JUDICE_NINKE);
+            break;
+        case '2': // Use Stucki dithering.
+            model->setDitherAlgorithm(STUCKI);
+            break;
+        default:
+            // Do nothing.
+            break;
         }
     }
 }