Merge branch 'master' of https://github.com/Kouzeru/ESP32-HUB75-MatrixPanel-DMA

8 files changed, 142 insertions, 98 deletions

diff --git a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp
index c1e7dd6..65429c3 100644
--- a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp
+++ b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp
@@ -23,7 +23,7 @@
 #endif 
 
 /* This library is designed to take an 8 bit / 1 byte value (0-255) for each R G B colour sub-pixel. 
- * The PIXEL_COLOUR_DEPTH_BITS should always be '8' as a result.
+ * The PIXEL_COLOR_DEPTH_BITS should always be '8' as a result.
  * However, if the library is to be used with lower colour depth (i.e. 6 bit colour), then we need to ensure the 8-bit value passed to the colour masking
  * is adjusted accordingly to ensure the LSB's are shifted left to MSB, by the difference. Otherwise the colours will be all screwed up.
  */
@@ -38,10 +38,10 @@
   //static constexpr uint8_t const MASK_OFFSET = 8-PIXEL_COLOUR_DEPTH_BITS;
 
 /*
-    #if PIXEL_COLOUR_DEPTH_BITS < 8
+    #if PIXEL_COLOR_DEPTH_BITS < 8
         uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit colour (8 bits per RGB subpixel)
     #else
-        uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit color (8 bits per RGB subpixel)
+        uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit colour (8 bits per RGB subpixel)
     #endif 
 */
 
@@ -61,11 +61,11 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
     size_t allocated_fb_memory = 0;
     for (int malloc_num =0; malloc_num < ROWS_PER_FRAME; ++malloc_num)
     {
-        auto ptr = std::make_shared<rowBitStruct>(PIXELS_PER_ROW, PIXEL_COLOUR_DEPTH_BITS, m_cfg.double_buff);
+        auto ptr = std::make_shared<rowBitStruct>(PIXELS_PER_ROW, PIXEL_COLOR_DEPTH_BITS, m_cfg.double_buff);
 
         if (ptr->data == nullptr)
         {
-            ESP_LOGE("I2S-DMA", "CRITICAL ERROR: Not enough memory for requested colour depth! Please reduce PIXEL_COLOUR_DEPTH_BITS value.\r\n");
+            ESP_LOGE("I2S-DMA", "CRITICAL ERROR: Not enough memory for requested colour depth! Please reduce PIXEL_COLOR_DEPTH_BITS value.\r\n");
             ESP_LOGE("I2S-DMA", "Could not allocate rowBitStruct %d!.\r\n", malloc_num);
 
             return false;
@@ -79,7 +79,7 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
     ESP_LOGI("I2S-DMA", "Allocating %d bytes memory for DMA BCM framebuffer(s).", allocated_fb_memory);        
    
     // calculate the lowest LSBMSB_TRANSITION_BIT value that will fit in memory that will meet or exceed the configured refresh rate
-#if !defined(FORCE_COLOUR_DEPTH)    
+#if !defined(FORCE_COLOR_DEPTH)    
 
     ESP_LOGI("I2S-DMA", "Minimum visual refresh rate (scan rate from panel top to bottom) requested: %d Hz", m_cfg.min_refresh_rate);	
 
@@ -88,11 +88,11 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
         int nsPerLatch = ((PIXELS_PER_ROW + CLKS_DURING_LATCH) * psPerClock) / 1000;
 
         // add time to shift out LSBs + LSB-MSB transition bit - this ignores fractions...
-        int nsPerRow = PIXEL_COLOUR_DEPTH_BITS * nsPerLatch;
+        int nsPerRow = PIXEL_COLOR_DEPTH_BITS * nsPerLatch;
 
         // add time to shift out MSBs
-        for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOUR_DEPTH_BITS; i++)
-            nsPerRow += (1<<(i - lsbMsbTransitionBit - 1)) * (PIXEL_COLOUR_DEPTH_BITS - i) * nsPerLatch;
+        for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOR_DEPTH_BITS; i++)
+            nsPerRow += (1<<(i - lsbMsbTransitionBit - 1)) * (PIXEL_COLOR_DEPTH_BITS - i) * nsPerLatch;
 
         int nsPerFrame = nsPerRow * ROWS_PER_FRAME;
         int actualRefreshRate = 1000000000UL/(nsPerFrame);
@@ -103,7 +103,7 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
         if (actualRefreshRate > m_cfg.min_refresh_rate) 
           break;
                   
-        if(lsbMsbTransitionBit < PIXEL_COLOUR_DEPTH_BITS - 1)
+        if(lsbMsbTransitionBit < PIXEL_COLOR_DEPTH_BITS - 1)
             lsbMsbTransitionBit++;
         else
             break;
@@ -122,7 +122,7 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
    *          memory allocation of the DMA linked list memory structure.
    */          
     int numDMAdescriptorsPerRow = 1;
-    for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOUR_DEPTH_BITS; i++) {
+    for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOR_DEPTH_BITS; i++) {
         numDMAdescriptorsPerRow += (1<<(i - lsbMsbTransitionBit - 1));
     }
 
@@ -133,9 +133,9 @@ bool MatrixPanel_I2S_DMA::allocateDMAmemory()
     if ( dma_buff.rowBits[0]->size() > DMA_MAX ) 
     {
 
-        ESP_LOGW("I2S-DMA", "rowColorDepthStruct struct is too large, split DMA payload required. Adding %d DMA descriptors\n", PIXEL_COLOUR_DEPTH_BITS-1);
+        ESP_LOGW("I2S-DMA", "rowBits struct is too large to fit in one DMA transfer payload, splitting required. Adding %d DMA descriptors\n", PIXEL_COLOR_DEPTH_BITS-1);
 
-        numDMAdescriptorsPerRow += PIXEL_COLOUR_DEPTH_BITS-1; 
+        numDMAdescriptorsPerRow += PIXEL_COLOR_DEPTH_BITS-1; 
         // Note: If numDMAdescriptorsPerRow is even just one descriptor too large, DMA linked list will not correctly loop.
     }
 
@@ -169,7 +169,7 @@ void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg)
     int current_dmadescriptor_offset = 0;
 
     // HACK: If we need to split the payload in 1/2 so that it doesn't breach DMA_MAX, lets do it by the colour_depth.
-    int num_dma_payload_colour_depths = PIXEL_COLOUR_DEPTH_BITS;
+    int num_dma_payload_colour_depths = PIXEL_COLOR_DEPTH_BITS;
     if ( dma_buff.rowBits[0]->size() > DMA_MAX ) {
         num_dma_payload_colour_depths = 1;
     }
@@ -195,7 +195,7 @@ void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg)
         if ( dma_buff.rowBits[0]->size() > DMA_MAX )
         {
           
-          for (int cd = 1; cd < PIXEL_COLOUR_DEPTH_BITS; cd++) 
+          for (int cd = 1; cd < PIXEL_COLOR_DEPTH_BITS; cd++) 
           {
             dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(cd, 0), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths), false);            
 
@@ -209,7 +209,7 @@ void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg)
         }  // row depth struct
 
 
-        for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOUR_DEPTH_BITS; i++) 
+        for(int i=lsbMsbTransitionBit + 1; i<PIXEL_COLOR_DEPTH_BITS; i++) 
         {
             // binary time division setup: we need 2 of bit (LSBMSB_TRANSITION_BIT + 1) four of (LSBMSB_TRANSITION_BIT + 2), etc
             // because we sweep through to MSB each time, it divides the number of times we have to sweep in half (saving linked list RAM)
@@ -217,10 +217,10 @@ void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg)
 
             for(int k=0; k < (1<<(i - lsbMsbTransitionBit - 1)); k++) 
             {
-                dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(i, 0),  dma_buff.rowBits[row]->size(PIXEL_COLOUR_DEPTH_BITS - i), false);
+                dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(i, 0),  dma_buff.rowBits[row]->size(PIXEL_COLOR_DEPTH_BITS - i), false);
 
                 if (m_cfg.double_buff) {
-                  dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(i, 1),  dma_buff.rowBits[row]->size(PIXEL_COLOUR_DEPTH_BITS - i), true );
+                  dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(i, 1),  dma_buff.rowBits[row]->size(PIXEL_COLOR_DEPTH_BITS - i), true );
                 }
 
                 current_dmadescriptor_offset++;
@@ -307,7 +307,7 @@ void IRAM_ATTR MatrixPanel_I2S_DMA::updateMatrixDMABuffer(uint16_t x_coord, uint
 
   /* LED Brightness Compensation. Because if we do a basic "red & mask" for example, 
      * we'll NEVER send the dimmest possible colour, due to binary skew.
-     * i.e. It's almost impossible for colour_depth_idx of 0 to be sent out to the MATRIX unless the 'value' of a color is exactly '1'
+     * i.e. It's almost impossible for colour_depth_idx of 0 to be sent out to the MATRIX unless the 'value' of a colour is exactly '1'
    * https://ledshield.wordpress.com/2012/11/13/led-brightness-to-your-eye-gamma-correction-no/
      */
 uint16_t red16, green16, blue16;
@@ -352,7 +352,7 @@ uint16_t red16, green16, blue16;
     }
 
     // Iterating through colour depth bits, which we assume are 8 bits per RGB subpixel (24bpp)
-    uint8_t colour_depth_idx = PIXEL_COLOUR_DEPTH_BITS;
+    uint8_t colour_depth_idx = PIXEL_COLOR_DEPTH_BITS;
     do {
         --colour_depth_idx;
 /*        
@@ -377,7 +377,7 @@ uint16_t red16, green16, blue16;
 
 
         // Get the contents at this address,
-        // it would represent a vector pointing to the full row of pixels for the specified color depth bit at Y coordinate
+        // it would represent a vector pointing to the full row of pixels for the specified colour depth bit at Y coordinate
         ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(y_coord, colour_depth_idx, back_buffer_id);
 
 
@@ -410,13 +410,13 @@ uint16_t red16, green16, blue16;
     blue16  = blue << 8;
 #endif
 
-  for(uint8_t colour_depth_idx=0; colour_depth_idx<PIXEL_COLOUR_DEPTH_BITS; colour_depth_idx++)  // color depth - 8 iterations
+  for(uint8_t colour_depth_idx=0; colour_depth_idx<PIXEL_COLOR_DEPTH_BITS; colour_depth_idx++)  // colour depth - 8 iterations
   {
     // let's precalculate RGB1 and RGB2 bits than flood it over the entire DMA buffer
     uint16_t RGB_output_bits = 0;
 //    uint8_t mask = (1 << colour_depth_idx COLOR_DEPTH_LESS_THAN_8BIT_ADJUST); // 24 bit colour
-    // #if PIXEL_COLOUR_DEPTH_BITS < 8
-    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit color (8 bits per RGB subpixel)
+    // #if PIXEL_COLOR_DEPTH_BITS < 8
+    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #else
     //     uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #endif      
@@ -536,13 +536,13 @@ void MatrixPanel_I2S_DMA::clearFrameBuffer(bool _buff_id){
     } // end SM5266P    
     
 
-    // let's set LAT/OE control bits for specific pixels in each color_index subrows
+    // let's set LAT/OE control bits for specific pixels in each colour_index subrows
     // Need to consider the original ESP32's (WROOM) DMA TX FIFO reordering of bytes...
     uint8_t colouridx = dma_buff.rowBits[row_idx]->colour_depth;
     do {
       --colouridx;
 
-      // switch pointer to a row for a specific color index
+      // switch pointer to a row for a specific colour index
       row = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id);
 
       /*
@@ -623,12 +623,12 @@ void MatrixPanel_I2S_DMA::brtCtrlOE(int brt, const bool _buff_id){
   do {
     --row_idx;
 
-    // let's set OE control bits for specific pixels in each color_index subrows
+    // let's set OE control bits for specific pixels in each colour_index subrows
     uint8_t colouridx = dma_buff.rowBits[row_idx]->colour_depth;
     do {
       --colouridx;
 
-      // switch pointer to a row for a specific color index
+      // switch pointer to a row for a specific colour index
       ESP32_I2S_DMA_STORAGE_TYPE* row = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id);
 
       int x_coord = dma_buff.rowBits[row_idx]->width;
@@ -674,7 +674,7 @@ void MatrixPanel_I2S_DMA::brtCtrlOE(int brt, const bool _buff_id){
 
     } while(colouridx);
 
-    // switch pointer to a row for a specific color index
+    // switch pointer to a row for a specific colour index
     #if defined(SPIRAM_DMA_BUFFER)          
         ESP32_I2S_DMA_STORAGE_TYPE* row_hack = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id);    
         Cache_WriteBack_Addr((uint32_t)row_hack, sizeof(ESP32_I2S_DMA_STORAGE_TYPE) * ((dma_buff.rowBits[row_idx]->width * dma_buff.rowBits[row_idx]->colour_depth)-1)) ;
@@ -765,7 +765,7 @@ void MatrixPanel_I2S_DMA::brtCtrlOEv2(uint8_t brt, const int _buff_id) {
 	  
     } while(colouridx);
 
-    // switch pointer to a row for a specific color index
+    // switch pointer to a row for a specific colour index
     #if defined(SPIRAM_DMA_BUFFER)          
         ESP32_I2S_DMA_STORAGE_TYPE* row_hack = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id);    
         Cache_WriteBack_Addr((uint32_t)row_hack, sizeof(ESP32_I2S_DMA_STORAGE_TYPE) * ((dma_buff.rowBits[row_idx]->width * dma_buff.rowBits[row_idx]->colour_depth)-1)) ;
@@ -824,7 +824,7 @@ uint8_t MatrixPanel_I2S_DMA::setLatBlanking(uint8_t pulses){
  * @param x_coord - line start coordinate x
  * @param y_coord - line start coordinate y
  * @param l - line length
- * @param r,g,b, - RGB888 color
+ * @param r,g,b, - RGB888 colour
  */
 void MatrixPanel_I2S_DMA::hlineDMA(int16_t x_coord, int16_t y_coord, int16_t l, uint8_t red, uint8_t green, uint8_t blue){
   if ( !initialized )
@@ -859,18 +859,18 @@ uint16_t red16, green16, blue16;
     y_coord -= ROWS_PER_FRAME;
   }
 
-  // Iterating through color depth bits (8 iterations)
-  uint8_t colour_depth_idx = PIXEL_COLOUR_DEPTH_BITS;
+  // Iterating through colour depth bits (8 iterations)
+  uint8_t colour_depth_idx = PIXEL_COLOR_DEPTH_BITS;
   do {
     --colour_depth_idx;
 
     // let's precalculate RGB1 and RGB2 bits than flood it over the entire DMA buffer
     uint16_t RGB_output_bits = 0;
 //    uint8_t mask = (1 << colour_depth_idx COLOR_DEPTH_LESS_THAN_8BIT_ADJUST);
-    // #if PIXEL_COLOUR_DEPTH_BITS < 8
-    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit color (8 bits per RGB subpixel)
+    // #if PIXEL_COLOR_DEPTH_BITS < 8
+    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #else
-    //     uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit color (8 bits per RGB subpixel)
+    //     uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #endif      
     uint16_t mask = PIXEL_COLOUR_MASK_BIT(colour_depth_idx);
 
@@ -884,7 +884,7 @@ uint16_t red16, green16, blue16;
     RGB_output_bits <<= _colourbitoffset;      // shift color bits to the required position
 
     // Get the contents at this address,
-    // it would represent a vector pointing to the full row of pixels for the specified color depth bit at Y coordinate
+    // it would represent a vector pointing to the full row of pixels for the specified colour depth bit at Y coordinate
     ESP32_I2S_DMA_STORAGE_TYPE *p = dma_buff.rowBits[y_coord]->getDataPtr(colour_depth_idx, back_buffer_id);
     // inlined version works slower here, dunno why :(
     // ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(y_coord, colour_depth_idx, back_buffer_id);
@@ -904,10 +904,10 @@ uint16_t red16, green16, blue16;
   */
         uint16_t &v = p[ESP32_TX_FIFO_POSITION_ADJUST(_x)];
 
-        v &= _colourbitclear;      // reset color bits
-        v |= RGB_output_bits;    // set new color bits
+        v &= _colourbitclear;      // reset colour bits
+        v |= RGB_output_bits;    // set new colour bits
     } while(_l);        // iterate pixels in a row
-  } while(colour_depth_idx);  // end of color depth loop (8)
+  } while(colour_depth_idx);  // end of colour depth loop (8)
 } // hlineDMA()
 
 
@@ -916,7 +916,7 @@ uint16_t red16, green16, blue16;
  * @param x_coord - line start coordinate x
  * @param y_coord - line start coordinate y
  * @param l - line length
- * @param r,g,b, - RGB888 color
+ * @param r,g,b, - RGB888 colour
  */
 void MatrixPanel_I2S_DMA::vlineDMA(int16_t x_coord, int16_t y_coord, int16_t l, uint8_t red, uint8_t green, uint8_t blue){
   if ( !initialized )
@@ -950,16 +950,16 @@ uint16_t red16, green16, blue16;
 */
   x_coord = ESP32_TX_FIFO_POSITION_ADJUST(x_coord);
 
-  uint8_t colour_depth_idx = PIXEL_COLOUR_DEPTH_BITS;
-  do {    // Iterating through color depth bits (8 iterations)
+  uint8_t colour_depth_idx = PIXEL_COLOR_DEPTH_BITS;
+  do {    // Iterating through colour depth bits (8 iterations)
     --colour_depth_idx;
 
     // let's precalculate RGB1 and RGB2 bits than flood it over the entire DMA buffer
 //    uint8_t mask = (1 << colour_depth_idx COLOR_DEPTH_LESS_THAN_8BIT_ADJUST);
-    // #if PIXEL_COLOUR_DEPTH_BITS < 8
-    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit color (8 bits per RGB subpixel)
+    // #if PIXEL_COLOR_DEPTH_BITS < 8
+    //     uint8_t mask = (1 << (colour_depth_idx+MASK_OFFSET)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #else
-    //     uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit color (8 bits per RGB subpixel)
+    //     uint8_t mask = (1 << (colour_depth_idx)); // expect 24 bit colour (8 bits per RGB subpixel)
     // #endif      
 
     uint16_t mask = PIXEL_COLOUR_MASK_BIT(colour_depth_idx);
@@ -984,7 +984,7 @@ uint16_t red16, green16, blue16;
       }
 
       // Get the contents at this address,
-      // it would represent a vector pointing to the full row of pixels for the specified color depth bit at Y coordinate
+      // it would represent a vector pointing to the full row of pixels for the specified colour depth bit at Y coordinate
       //ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(_y, colour_depth_idx, back_buffer_id);
       ESP32_I2S_DMA_STORAGE_TYPE *p = dma_buff.rowBits[_y]->getDataPtr(colour_depth_idx, back_buffer_id);      
 
@@ -992,7 +992,7 @@ uint16_t red16, green16, blue16;
       p[x_coord] |= RGB_output_bits;  // set new RGB bits
       ++_y;
     } while(++_l!=l);        // iterate pixels in a col
-  } while(colour_depth_idx);  // end of color depth loop (8)
+  } while(colour_depth_idx);  // end of colour depth loop (8)
 } // vlineDMA()
 
 
@@ -1001,9 +1001,9 @@ uint16_t red16, green16, blue16;
  * this works much faster than multiple consecutive per-pixel calls to updateMatrixDMABuffer()
  * @param int16_t x, int16_t y - coordinates of a top-left corner
  * @param int16_t w, int16_t h - width and height of a rectangular, min is 1 px
- * @param uint8_t r - RGB888 color
- * @param uint8_t g - RGB888 color
- * @param uint8_t b - RGB888 color
+ * @param uint8_t r - RGB888 colour
+ * @param uint8_t g - RGB888 colour
+ * @param uint8_t b - RGB888 colour
  */
 void MatrixPanel_I2S_DMA::fillRectDMA(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t r, uint8_t g, uint8_t b){
 
diff --git a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.h b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.h
index 200530e..91e89a6 100644
--- a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.h
+++ b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.h
@@ -67,10 +67,15 @@
 // 8bit per RGB color = 24 bit/per pixel,
 // can be extended to offer deeper colors, or
 // might be reduced to save DMA RAM
-#ifndef PIXEL_COLOUR_DEPTH_BITS
- #define PIXEL_COLOUR_DEPTH_BITS      8
+#ifdef PIXEL_COLOUR_DEPTH_BITS
+ #define PIXEL_COLOR_DEPTH_BITS      PIXEL_COLOUR_DEPTH_BITS
 #endif
 
+#ifndef PIXEL_COLOR_DEPTH_BITS
+ #define PIXEL_COLOR_DEPTH_BITS      8
+#endif
+
+
 /***************************************************************************************/
 /* Definitions below should NOT be ever changed without rewriting library logic         */
 #define ESP32_I2S_DMA_STORAGE_TYPE  uint16_t                // DMA output of one uint16_t at a time.
@@ -125,7 +130,7 @@ struct rowBitStruct {
     ESP32_I2S_DMA_STORAGE_TYPE *data;
 
     /** @brief - returns size of row of data vectorfor a SINGLE buff
-     * size (in bytes) of a vector holding full DMA data for a row of pixels with _dpth color bits
+     * size (in bytes) of a vector holding full DMA data for a row of pixels with _dpth colour bits
      * a SINGLE buffer only size is accounted, when using double buffers it actually takes twice as much space
      * but returned size is for a half of double-buffer
      * 
@@ -134,7 +139,7 @@ struct rowBitStruct {
      */
     size_t size(uint8_t _dpth=0 ) { if (!_dpth) _dpth = colour_depth; return width * _dpth * sizeof(ESP32_I2S_DMA_STORAGE_TYPE); };
 
-    /** @brief - returns pointer to the row's data vector beginning at pixel[0] for _dpth color bit
+    /** @brief - returns pointer to the row's data vector beginning at pixel[0] for _dpth colour bit
      * default - returns pointer to the data vector's head
      * NOTE: this call might be very slow in loops. Due to poor instruction caching in esp32 it might be required a reread from flash 
      * every loop cycle, better use inlined #define instead in such cases
@@ -171,7 +176,7 @@ struct rowBitStruct {
  *       are contained in parallel within the one uint16_t that is sent in parallel to the HUB75). 
  * 
  *       This structure isn't actually allocated in one memory block anymore, as the library now allocates
- *       memory per row (per rowColorDepthStruct) instead.
+ *       memory per row (per rowBits) instead.
  */
 struct frameStruct {
     uint8_t rows=0;    // number of rows held in current frame, not used actually, just to keep the idea of struct
@@ -225,7 +230,7 @@ struct  HUB75_I2S_CFG {
   /**
    * I2S clock speed selector
    */
-  enum clk_speed {HZ_10M=10000000, HZ_15M=15000000, HZ_20M=20000000};
+  enum clk_speed {HZ_8M=8000000, HZ_10M=10000000, HZ_15M=15000000, HZ_20M=20000000};
 
   // Structure Variables
 
@@ -290,7 +295,8 @@ struct  HUB75_I2S_CFG {
       mx_height(_h),
       chain_length(_chain),
       gpio(_pinmap),
-      driver(_drv), i2sspeed(_i2sspeed),
+      driver(_drv), 
+	  i2sspeed(_i2sspeed),
       double_buff(_dbuff),
       latch_blanking(_latblk),
       clkphase(_clockphase),
@@ -365,6 +371,11 @@ class MatrixPanel_I2S_DMA {
       if (m_cfg.driver)
         shiftDriver(m_cfg);
           
+        #if defined(SPIRAM_DMA_BUFFER)     
+		 // Trick library into dropping colour depth slightly when using PSRAM.
+		 // Actual output clockrate override occurs in configureDMA
+          m_cfg.i2sspeed = HUB75_I2S_CFG::HZ_8M;
+        #endif	           
 
      /* As DMA buffers are dynamically allocated, we must allocated in begin()
       * Ref: https://github.com/espressif/arduino-esp32/issues/831
@@ -470,7 +481,7 @@ class MatrixPanel_I2S_DMA {
 
     void drawIcon (int *ico, int16_t x, int16_t y, int16_t cols, int16_t rows);
     
-    // Color 444 is a 4 bit scale, so 0 to 15, color 565 takes a 0-255 bit value, so scale up by 255/15 (i.e. 17)!
+    // Colour 444 is a 4 bit scale, so 0 to 15, colour 565 takes a 0-255 bit value, so scale up by 255/15 (i.e. 17)!
     static uint16_t color444(uint8_t r, uint8_t g, uint8_t b) { return color565(r*17,g*17,b*17); }
 
     // Converts RGB888 to RGB565
@@ -481,7 +492,7 @@ class MatrixPanel_I2S_DMA {
 
     /**
      * @brief - convert RGB565 to RGB888
-     * @param uint16_t color - RGB565 input color
+     * @param uint16_t colour - RGB565 input colour
      * @param uint8_t &r, &g, &b - refs to variables where converted colors would be emplaced
      */
     static void color565to888(const uint16_t color, uint8_t &r, uint8_t &g, uint8_t &b);
@@ -620,9 +631,9 @@ class MatrixPanel_I2S_DMA {
     Bus_Parallel16 dma_bus;
 
     /**
-     * @brief - clears and reinitializes color/control data in DMA buffs
+     * @brief - clears and reinitializes colour/control data in DMA buffs
      * When allocated, DMA buffs might be dirty, so we need to blank it and initialize ABCDE,LAT,OE control bits.
-     * Those control bits are constants during the entire DMA sweep and never changed when updating just pixel color data
+     * Those control bits are constants during the entire DMA sweep and never changed when updating just pixel colour data
      * so we could set it once on DMA buffs initialization and forget. 
      * This effectively clears buffers to blank BLACK and makes it ready to display output.
      * (Brightness control via OE bit manipulation is another case)
@@ -636,7 +647,7 @@ class MatrixPanel_I2S_DMA {
     void updateMatrixDMABuffer(uint8_t red, uint8_t green, uint8_t blue);       
 
     /**
-     * wipes DMA buffer(s) and reset all color/service bits
+     * wipes DMA buffer(s) and reset all colour/service bits
      */
     inline void resetbuffers(){
 		
@@ -657,7 +668,7 @@ class MatrixPanel_I2S_DMA {
      * @param x_ccord - line start coordinate x
      * @param y_ccord - line start coordinate y
      * @param l - line length
-     * @param r,g,b, - RGB888 color
+     * @param r,g,b, - RGB888 colour
      */
     void hlineDMA(int16_t x_coord, int16_t y_coord, int16_t l, uint8_t red, uint8_t green, uint8_t blue);
 
@@ -666,7 +677,7 @@ class MatrixPanel_I2S_DMA {
      * @param x_ccord - line start coordinate x
      * @param y_ccord - line start coordinate y
      * @param l - line length
-     * @param r,g,b, - RGB888 color
+     * @param r,g,b, - RGB888 colour
      */
     void vlineDMA(int16_t x_coord, int16_t y_coord, int16_t l, uint8_t red, uint8_t green, uint8_t blue);
 
@@ -675,9 +686,9 @@ class MatrixPanel_I2S_DMA {
      * uses Fast H/V line draw internally, works faster than multiple consecutive pixel by pixel calls to updateMatrixDMABuffer()
      * @param int16_t x, int16_t y - coordinates of a top-left corner
      * @param int16_t w, int16_t h - width and height of a rectangular, min is 1 px
-     * @param uint8_t r - RGB888 color
-     * @param uint8_t g - RGB888 color
-     * @param uint8_t b - RGB888 color
+     * @param uint8_t r - RGB888 colour
+     * @param uint8_t g - RGB888 colour
+     * @param uint8_t b - RGB888 colour
      */
     void fillRectDMA(int16_t x_coord, int16_t y_coord, int16_t w, int16_t h, uint8_t r, uint8_t g, uint8_t b);
 #endif
@@ -761,7 +772,7 @@ class MatrixPanel_I2S_DMA {
 
 /**
  * @brief - convert RGB565 to RGB888
- * @param uint16_t color - RGB565 input color
+ * @param uint16_t colour - RGB565 input colour
  * @param uint8_t &r, &g, &b - refs to variables where converted colours would be emplaced
  */
 inline void MatrixPanel_I2S_DMA::color565to888(const uint16_t color, uint8_t &r, uint8_t &g, uint8_t &b){
@@ -810,7 +821,7 @@ inline void MatrixPanel_I2S_DMA::fillScreen(CRGB color)
 #endif
 
 
-// Pass 8-bit (each) R,G,B, get back 16-bit packed color
+// Pass 8-bit (each) R,G,B, get back 16-bit packed colour
 //https://github.com/squix78/ILI9341Buffer/blob/master/ILI9341_SPI.cpp
 inline uint16_t MatrixPanel_I2S_DMA::color565(uint8_t r, uint8_t g, uint8_t b) {
   return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
@@ -879,7 +890,7 @@ inline void MatrixPanel_I2S_DMA::drawIcon (int *ico, int16_t x, int16_t y, int16
     only one line is showed at a time, and the display looks like every pixel is driven at the same time.
 
     Now, the RGB inputs for these types of displays are digital, meaning each red, green and blue subpixel can only be on or off. This leads to a
-    color palette of 8 pixels, not enough to display nice pictures. To get around this, we use binary code modulation.
+    colour palette of 8 pixels, not enough to display nice pictures. To get around this, we use binary code modulation.
 
     Binary code modulation is somewhat like PWM, but easier to implement in our case. First, we define the time we would refresh the display without
     binary code modulation as the 'frame time'. For, say, a four-bit binary code modulation, the frame time is divided into 15 ticks of equal length.
diff --git a/src/ESP32-VirtualMatrixPanel-I2S-DMA.h b/src/ESP32-VirtualMatrixPanel-I2S-DMA.h
index b2aba42..ea49388 100644
--- a/src/ESP32-VirtualMatrixPanel-I2S-DMA.h
+++ b/src/ESP32-VirtualMatrixPanel-I2S-DMA.h
@@ -9,9 +9,17 @@
     grid.
 
     However, the function of this class has expanded now to also manage
-    the output for 1/16 scan panels, as the core DMA library is designed
-    ONLY FOR 1/16 scan matrix panels.
-
+    the output for
+	
+	1) HALF scan panels = Two rows updated in parallel. 
+		* 64px high panel =  (incorrectly) referred to as 1/32 scan
+		* 32px high panel =  (incorrectly) referred to as 1/16 scan
+		* 16px high panel =  (incorrectly) referred to as 1/8 scan
+		
+	2) FOUR scan panels = Four rows updated in parallel
+		* 32px high panel = (incorrectly) referred to as 1/8 scan 
+		* 16px high panel = (incorrectly) referred to as 1/4 scan 
+		
     YouTube: https://www.youtube.com/brianlough
     Tindie: https://www.tindie.com/stores/brianlough/
     Twitter: https://twitter.com/witnessmenow
@@ -36,9 +44,9 @@ struct VirtualCoords
 
 enum PANEL_SCAN_RATE
 {
-  NORMAL_ONE_SIXTEEN,
-  ONE_EIGHT_32,
-  ONE_EIGHT_16
+  NORMAL_TWO_SCAN, NORMAL_ONE_SIXTEEN, // treated as the same
+  FOUR_SCAN_32PX_HIGH,
+  FOUR_SCAN_16PX_HIGH
 };
 
 #ifdef USE_GFX_ROOT
@@ -129,7 +137,7 @@ protected:
   bool _chain_top_down = false; // is the ESP at the top or bottom of the matrix of devices?
   bool _rotate = false;
 
-  PANEL_SCAN_RATE _panelScanRate = NORMAL_ONE_SIXTEEN;
+  PANEL_SCAN_RATE _panelScanRate = NORMAL_TWO_SCAN;
 
 }; // end Class header
 
@@ -198,18 +206,18 @@ inline VirtualCoords VirtualMatrixPanel::getCoords(int16_t &x, int16_t &y)
     coords.y = (panelResY - 1) - coords.y;
   }
 
-  /* START: Pixel remapping AGAIN to convert 1/16 SCAN output that the
+  /* START: Pixel remapping AGAIN to convert TWO parallel scanline output that the
    *        the underlying hardware library is designed for (because
-   *        there's only 2 x RGB pins... and convert this to 1/8 or something
+   *        there's only 2 x RGB pins... and convert this to 1/4 or something
    */
-  if (_panelScanRate == ONE_EIGHT_32)
+  if (_panelScanRate == FOUR_SCAN_32PX_HIGH)
   {
     /* Convert Real World 'VirtualMatrixPanel' co-ordinates (i.e. Real World pixel you're looking at
        on the panel or chain of panels, per the chaining configuration) to a 1/8 panels
        double 'stretched' and 'squished' coordinates which is what needs to be sent from the
        DMA buffer.
 
-       Note: Look at the One_Eight_1_8_ScanPanel code and you'll see that the DMA buffer is setup
+       Note: Look at the FourScanPanel example code and you'll see that the DMA buffer is setup
        as if the panel is 2 * W and 0.5 * H !
     */
 
@@ -238,7 +246,7 @@ inline VirtualCoords VirtualMatrixPanel::getCoords(int16_t &x, int16_t &y)
      Serial.print("to ("); Serial.print(coords.x, DEC);  Serial.print(",");  Serial.print(coords.y, DEC);   Serial.println(") ");
     */
   }
-  else if (_panelScanRate == ONE_EIGHT_16)
+  else if (_panelScanRate == FOUR_SCAN_16PX_HIGH)
   {
     if ((y & 8) == 0)
     {
diff --git a/src/platforms/esp32/RGB_HUB75_PINS.png b/src/platforms/esp32/RGB_HUB75_PINS.png
new file mode 100644
index 0000000..2dc609e
--- /dev/null
+++ b/src/platforms/esp32/RGB_HUB75_PINS.png
diff --git a/src/platforms/esp32/esp32_i2s_parallel_dma.cpp b/src/platforms/esp32/esp32_i2s_parallel_dma.cpp
index 6b64200..f74274e 100644
--- a/src/platforms/esp32/esp32_i2s_parallel_dma.cpp
+++ b/src/platforms/esp32/esp32_i2s_parallel_dma.cpp
@@ -291,7 +291,7 @@ static void IRAM_ATTR irq_hndlr(void* arg) { // if we use I2S1 (default)
 
 		///auto _div_num = 80000000L/freq;
 
-		ESP_LOGD("ESP32", "i2s pll_d2_clock clkm_div_num is: %d", _div_num);    		
+		ESP_LOGD("ESP32", "i2s pll_d2_clock clkm_div_num is: %ld", _div_num);    		
 
 		dev->clkm_conf.clka_en=1;         // Use the 80mhz system clock (PLL_D2_CLK) when '0'
 		dev->clkm_conf.clkm_div_a = 1;      // Clock denominator 
@@ -304,7 +304,7 @@ static void IRAM_ATTR irq_hndlr(void* arg) { // if we use I2S1 (default)
  
 
 	output_freq = output_freq + 0; // work around arudino 'unused var' issue if debug isn't enabled.
-    ESP_LOGI("ESP32/S2", "Output frequency is %d Mhz??", (output_freq/1000000/i2s_parallel_get_memory_width(ESP32_I2S_DEVICE, 16)));    	
+    ESP_LOGI("ESP32/S2", "Output frequency is %ld Mhz??", (output_freq/1000000/i2s_parallel_get_memory_width(ESP32_I2S_DEVICE, 16)));    	
 
 
     // Setup i2s clock
@@ -662,4 +662,4 @@ static void IRAM_ATTR irq_hndlr(void* arg) { // if we use I2S1 (default)
 
 
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/platforms/esp32/esp32_i2s_parallel_dma.hpp b/src/platforms/esp32/esp32_i2s_parallel_dma.hpp
index 0fb68d2..dd6c1f3 100644
--- a/src/platforms/esp32/esp32_i2s_parallel_dma.hpp
+++ b/src/platforms/esp32/esp32_i2s_parallel_dma.hpp
@@ -49,7 +49,9 @@ Contributors:
 
 #define DMA_MAX (4096-4)
 
-#define ESP32_I2S_DEVICE I2S_NUM_0	
+#ifndef ESP32_I2S_DEVICE 
+  #define ESP32_I2S_DEVICE I2S_NUM_0	
+#endif 
 
 // The type used for this SoC
 #define HUB75_DMA_DESCRIPTOR_T lldesc_t
@@ -144,4 +146,4 @@ i2s_dev_t* getDev();
     
     
 
-  };
\ No newline at end of file
+  };
diff --git a/src/platforms/esp32s3/gdma_lcd_parallel16.cpp b/src/platforms/esp32s3/gdma_lcd_parallel16.cpp
index 314bb99..d773b55 100644
--- a/src/platforms/esp32s3/gdma_lcd_parallel16.cpp
+++ b/src/platforms/esp32s3/gdma_lcd_parallel16.cpp
@@ -30,8 +30,8 @@
 //  static const char* TAG = "gdma_lcd_parallel16";
 //#endif  
 
-  static int _dmadesc_a_idx = 0;
-  static int _dmadesc_b_idx = 0;  
+  //static int _dmadesc_a_idx = 0;
+  //static int _dmadesc_b_idx = 0;  
 
 
   dma_descriptor_t desc;          // DMA descriptor for testing
@@ -98,22 +98,44 @@
     //LCD_CAM.lcd_clock.clk_en = 0;             // Enable peripheral clock
 
     // LCD_CAM_LCD_CLK_SEL Select LCD module source clock. 0: clock source is disabled. 1: XTAL_CLK. 2: PLL_D2_CLK. 3: PLL_F160M_CLK. (R/W)
-    LCD_CAM.lcd_clock.lcd_clk_sel = 2;        
+    LCD_CAM.lcd_clock.lcd_clk_sel = 3;        // Use 160Mhz Clock Source
+	
     LCD_CAM.lcd_clock.lcd_ck_out_edge = 0;    // PCLK low in 1st half cycle
     LCD_CAM.lcd_clock.lcd_ck_idle_edge = 0;   // PCLK low idle
-    LCD_CAM.lcd_clock.lcd_clk_equ_sysclk = 0; // PCLK = CLK / (CLKCNT_N+1)
+	
+	LCD_CAM.lcd_clock.lcd_clkcnt_n = 1; // Should never be zero
+	
+    //LCD_CAM.lcd_clock.lcd_clk_equ_sysclk = 0; // PCLK = CLK / (CLKCNT_N+1)	
+	LCD_CAM.lcd_clock.lcd_clk_equ_sysclk = 1; // PCLK = CLK / 1 (... so 160Mhz still)
 
 
     if (_cfg.psram_clk_override) // fastest speed I can get PSRAM to work before nothing shows
     {
-      LCD_CAM.lcd_clock.lcd_clkm_div_num = 4; 
+        ESP_LOGI("S3", "DMA buffer is on PSRAM. Limiting clockspeed....");   
+        LCD_CAM.lcd_clock.lcd_clkm_div_num = 10; //16mhz is the fasted the Octal PSRAM can support it seems 
     }
     else
     {
+		
+	  auto freq 		= (_cfg.bus_freq);
+	  
+	  auto _div_num = 8; // 20Mhz 
+	  if (freq < 20000000L)
+	  {
+		  _div_num = 12; // 13Mhz
+	  }
+	  else if (freq > 20000000L)
+	  {
+		  _div_num = 6; // 26Mhz --- likely to have noise without a good connection		  
+	  }
+	    
       //LCD_CAM.lcd_clock.lcd_clkm_div_num = lcd_clkm_div_num;      
-      LCD_CAM.lcd_clock.lcd_clkm_div_num = 3;      
+      LCD_CAM.lcd_clock.lcd_clkm_div_num = _div_num; //3;      
+
     }
-     ESP_LOGI("S3", "Clock divider is %d", LCD_CAM.lcd_clock.lcd_clkm_div_num);     
+     ESP_LOGI("S3", "Clock divider is %d", LCD_CAM.lcd_clock.lcd_clkm_div_num);   
+
+	 ESP_LOGD("S3", "Resulting output clock frequency: %ld Mhz",  (160000000L/LCD_CAM.lcd_clock.lcd_clkm_div_num)); 
 
     
     LCD_CAM.lcd_clock.lcd_clkm_div_a = 1;     // 0/1 fractional divide
@@ -441,4 +463,4 @@
   } // end flip
 
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/platforms/esp32s3/gdma_lcd_parallel16.hpp b/src/platforms/esp32s3/gdma_lcd_parallel16.hpp
index 3cb94e8..3d47c22 100644
--- a/src/platforms/esp32s3/gdma_lcd_parallel16.hpp
+++ b/src/platforms/esp32s3/gdma_lcd_parallel16.hpp
@@ -157,8 +157,9 @@
     gdma_channel_handle_t dma_chan; 
 
     uint32_t _dmadesc_count  = 0;   // number of dma decriptors
-   // uint32_t _dmadesc_a_idx  = 0;
-    //uint32_t _dmadesc_b_idx  = 0;
+	
+    uint32_t _dmadesc_a_idx  = 0;
+    uint32_t _dmadesc_b_idx  = 0;
 
     HUB75_DMA_DESCRIPTOR_T* _dmadesc_a = nullptr;
     HUB75_DMA_DESCRIPTOR_T* _dmadesc_b = nullptr;