From 9d36abeeafbcdefda4fb9bfbf28c5af3276d297e Mon Sep 17 00:00:00 2001 From: mrfaptastic <12006953+mrfaptastic@users.noreply.github.com> Date: Sat, 18 Mar 2023 20:12:45 +0000 Subject: Reduce #338 --- src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp | 1137 +++++++++++++++---------------- 1 file changed, 548 insertions(+), 589 deletions(-) (limited to 'src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp') diff --git a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp index 694150e..92d7ac3 100644 --- a/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp +++ b/src/ESP32-HUB75-MatrixPanel-I2S-DMA.cpp @@ -1,283 +1,293 @@ #include "ESP32-HUB75-MatrixPanel-I2S-DMA.h" #if defined(SPIRAM_DMA_BUFFER) - // Sprite_TM saves the day again... - // https://www.esp32.com/viewtopic.php?f=2&t=30584 - #include "rom/cache.h" -#endif +// Sprite_TM saves the day again... +// https://www.esp32.com/viewtopic.php?f=2&t=30584 +#include "rom/cache.h" +#endif -/* This replicates same function in rowBitStruct, but due to induced inlining it might be MUCH faster - * when used in tight loops while method from struct could be flushed out of instruction cache between +/* This replicates same function in rowBitStruct, but due to induced inlining it might be MUCH faster + * when used in tight loops while method from struct could be flushed out of instruction cache between * loop cycles do NOT forget about buff_id param if using this. */ -#define getRowDataPtr(row, _dpth, buff_id) &(dma_buff.rowBits[row]->data[_dpth * dma_buff.rowBits[row]->width + buff_id*(dma_buff.rowBits[row]->width * dma_buff.rowBits[row]->colour_depth)]) +// #define getRowDataPtr(row, _dpth, buff_id) &(dma_buff.rowBits[row]->data[_dpth * dma_buff.rowBits[row]->width + buff_id*(dma_buff.rowBits[row]->width * dma_buff.rowBits[row]->colour_depth)]) + +// BufferID is now ignored, seperate global pointer pointer! +#define getRowDataPtr(row, _dpth, buff_id) &(fb->rowBits[row]->data[_dpth * fb->rowBits[row]->width]) /* We need to update the correct uint16_t in the rowBitStruct array, that gets sent out in parallel * 16 bit parallel mode - Save the calculated value to the bitplane memory in reverse order to account for I2S Tx FIFO mode1 ordering * Irrelevant for ESP32-S2 the way the FIFO ordering works is different - refer to page 679 of S2 technical reference manual */ -#if defined (ESP32_THE_ORIG) - #define ESP32_TX_FIFO_POSITION_ADJUST(x_coord) (((x_coord) & 1U) ? (x_coord-1):(x_coord+1)) -#else - #define ESP32_TX_FIFO_POSITION_ADJUST(x_coord) x_coord -#endif +#if defined(ESP32_THE_ORIG) +#define ESP32_TX_FIFO_POSITION_ADJUST(x_coord) (((x_coord)&1U) ? (x_coord - 1) : (x_coord + 1)) +#else +#define ESP32_TX_FIFO_POSITION_ADJUST(x_coord) x_coord +#endif -/* This library is designed to take an 8 bit / 1 byte value (0-255) for each R G B colour sub-pixel. +/* This library is designed to take an 8 bit / 1 byte value (0-255) for each R G B colour sub-pixel. * 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. */ -//#if PIXEL_COLOR_DEPTH_BITS > 12 -// #error "Color depth bits cannot be greater than 12." -//#elif PIXEL_COLOR_DEPTH_BITS < 2 -// #error "Color depth bits cannot be less than 2." -//#endif +// #if PIXEL_COLOR_DEPTH_BITS > 12 +// #error "Color depth bits cannot be greater than 12." +// #elif PIXEL_COLOR_DEPTH_BITS < 2 +// #error "Color depth bits cannot be less than 2." +// #endif - //#define MASK_OFFSET (16 - PIXEL_COLOR_DEPTH_BITS) - //#define PIXEL_COLOR_MASK_BIT(color_depth_index) (1 << (color_depth_index + MASK_OFFSET)) - #define PIXEL_COLOR_MASK_BIT(color_depth_index, mask_offset) (1 << (color_depth_index + mask_offset)) - //static constexpr uint8_t const MASK_OFFSET = 8-PIXEL_COLOUR_DEPTH_BITS; +// #define MASK_OFFSET (16 - PIXEL_COLOR_DEPTH_BITS) +// #define PIXEL_COLOR_MASK_BIT(color_depth_index) (1 << (color_depth_index + MASK_OFFSET)) +#define PIXEL_COLOR_MASK_BIT(color_depth_index, mask_offset) (1 << (color_depth_index + mask_offset)) +// static constexpr uint8_t const MASK_OFFSET = 8-PIXEL_COLOUR_DEPTH_BITS; /* #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 + #endif */ - bool MatrixPanel_I2S_DMA::allocateDMAmemory() { - ESP_LOGI("I2S-DMA", "Free heap: %d", heap_caps_get_free_size(MALLOC_CAP_INTERNAL)); - ESP_LOGI("I2S-DMA", "Free SPIRAM: %d", heap_caps_get_free_size(MALLOC_CAP_SPIRAM)); - + ESP_LOGI("I2S-DMA", "Free heap: %d", heap_caps_get_free_size(MALLOC_CAP_INTERNAL)); + ESP_LOGI("I2S-DMA", "Free SPIRAM: %d", heap_caps_get_free_size(MALLOC_CAP_SPIRAM)); // Alright, theoretically we should be OK, so let us do this, so // lets allocate a chunk of memory for each row (a row could span multiple panels if chaining is in place) - dma_buff.rowBits.reserve(ROWS_PER_FRAME); + ESP_LOGI("I2S-DMA", "allocating rowBitStructs with pixel_color_depth_bits of %d", m_cfg.getPixelColorDepthBits()); + // iterate through number of rows, allocate memory for each + size_t allocated_fb_memory = 0; - ESP_LOGI("I2S-DMA", "allocating rowBitStructs with pixel_color_depth_bits of %d", m_cfg.getPixelColorDepthBits()); - // iterate through number of rows, allocate memory for each - size_t allocated_fb_memory = 0; - for (int malloc_num =0; malloc_num < ROWS_PER_FRAME; ++malloc_num) + int fbs_required = (m_cfg.double_buff) ? 2 : 1; + for (int fb = 0; fb < fbs_required; fb++) + { + frame_buffer[fb].rowBits.reserve(ROWS_PER_FRAME); + + for (int malloc_num = 0; malloc_num < ROWS_PER_FRAME; ++malloc_num) { - auto ptr = std::make_shared(PIXELS_PER_ROW, m_cfg.getPixelColorDepthBits(), m_cfg.double_buff); + auto ptr = std::make_shared(PIXELS_PER_ROW, m_cfg.getPixelColorDepthBits(), m_cfg.double_buff); - if (ptr->data == nullptr) - { - 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); + if (ptr->data == nullptr) + { + 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; - // TODO: should we release all previous rowBitStructs here??? - } + return false; + // TODO: should we release all previous rowBitStructs here??? + } - allocated_fb_memory += ptr->size(); - dma_buff.rowBits.emplace_back(ptr); // save new rowBitStruct into rows vector - ++dma_buff.rows; + allocated_fb_memory += ptr->size(); + frame_buffer[fb].rowBits.emplace_back(ptr); // save new rowBitStruct into rows vector + ++frame_buffer[fb].rows; } - 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_COLOR_DEPTH) + } + ESP_LOGI("I2S-DMA", "Allocating %d bytes memory for DMA BCM framebuffer(s).", allocated_fb_memory); - ESP_LOGI("I2S-DMA", "Minimum visual refresh rate (scan rate from panel top to bottom) requested: %d Hz", m_cfg.min_refresh_rate); + // calculate the lowest LSBMSB_TRANSITION_BIT value that will fit in memory that will meet or exceed the configured refresh rate +#if !defined(FORCE_COLOR_DEPTH) - while(1) { - int psPerClock = 1000000000000UL/m_cfg.i2sspeed; - int nsPerLatch = ((PIXELS_PER_ROW + CLKS_DURING_LATCH) * psPerClock) / 1000; + ESP_LOGI("I2S-DMA", "Minimum visual refresh rate (scan rate from panel top to bottom) requested: %d Hz", m_cfg.min_refresh_rate); - // add time to shift out LSBs + LSB-MSB transition bit - this ignores fractions... - int nsPerRow = m_cfg.getPixelColorDepthBits() * nsPerLatch; + while (1) + { + int psPerClock = 1000000000000UL / m_cfg.i2sspeed; + int nsPerLatch = ((PIXELS_PER_ROW + CLKS_DURING_LATCH) * psPerClock) / 1000; - // add time to shift out MSBs - for(int i=lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); i++) - nsPerRow += (1<<(i - lsbMsbTransitionBit - 1)) * (m_cfg.getPixelColorDepthBits() - i) * nsPerLatch; + // add time to shift out LSBs + LSB-MSB transition bit - this ignores fractions... + int nsPerRow = m_cfg.getPixelColorDepthBits() * nsPerLatch; - int nsPerFrame = nsPerRow * ROWS_PER_FRAME; - int actualRefreshRate = 1000000000UL/(nsPerFrame); - calculated_refresh_rate = actualRefreshRate; + // add time to shift out MSBs + for (int i = lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); i++) + nsPerRow += (1 << (i - lsbMsbTransitionBit - 1)) * (m_cfg.getPixelColorDepthBits() - i) * nsPerLatch; - ESP_LOGW("I2S-DMA", "lsbMsbTransitionBit of %d gives %d Hz refresh rate.", lsbMsbTransitionBit, actualRefreshRate); + int nsPerFrame = nsPerRow * ROWS_PER_FRAME; + int actualRefreshRate = 1000000000UL / (nsPerFrame); + calculated_refresh_rate = actualRefreshRate; + + ESP_LOGW("I2S-DMA", "lsbMsbTransitionBit of %d gives %d Hz refresh rate.", lsbMsbTransitionBit, actualRefreshRate); + + if (actualRefreshRate > m_cfg.min_refresh_rate) + break; + + if (lsbMsbTransitionBit < m_cfg.getPixelColorDepthBits() - 1) + lsbMsbTransitionBit++; + else + break; + } + + if (lsbMsbTransitionBit > 0) + { + ESP_LOGW("I2S-DMA", "lsbMsbTransitionBit of %d used to achieve refresh rate of %d Hz. Percieved colour depth to the eye may be reduced.", lsbMsbTransitionBit, m_cfg.min_refresh_rate); + } - if (actualRefreshRate > m_cfg.min_refresh_rate) - break; - - if(lsbMsbTransitionBit < m_cfg.getPixelColorDepthBits() - 1) - lsbMsbTransitionBit++; - else - break; - } - - if ( lsbMsbTransitionBit > 0 ) - { - ESP_LOGW("I2S-DMA", "lsbMsbTransitionBit of %d used to achieve refresh rate of %d Hz. Percieved colour depth to the eye may be reduced.", lsbMsbTransitionBit, m_cfg.min_refresh_rate); - } - ESP_LOGI("I2S-DMA", "DMA has pixel_color_depth_bits of %d", m_cfg.getPixelColorDepthBits() - lsbMsbTransitionBit); #endif - /*** * Step 2a: lsbMsbTransition bit is now finalised - recalculate the DMA descriptor count required, which is used for * memory allocation of the DMA linked list memory structure. - */ - int numDMAdescriptorsPerRow = 1; - for(int i=lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); i++) { - numDMAdescriptorsPerRow += (1<<(i - lsbMsbTransitionBit - 1)); - } + */ + int numDMAdescriptorsPerRow = 1; + for (int i = lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); i++) + { + numDMAdescriptorsPerRow += (1 << (i - lsbMsbTransitionBit - 1)); + } - ESP_LOGI("I2S-DMA", "Recalculated number of DMA descriptors per row: %d", numDMAdescriptorsPerRow); + ESP_LOGI("I2S-DMA", "Recalculated number of DMA descriptors per row: %d", numDMAdescriptorsPerRow); - // Refer to 'DMA_LL_PAYLOAD_SPLIT' code in configureDMA() below to understand why this exists. - // numDMAdescriptorsPerRow is also used to calculate descount which is super important in i2s_parallel_config_t SoC DMA setup. - if ( dma_buff.rowBits[0]->size() > DMA_MAX ) - { - - ESP_LOGW("I2S-DMA", "rowBits struct is too large to fit in one DMA transfer payload, splitting required. Adding %d DMA descriptors\n", m_cfg.getPixelColorDepthBits()-1); + // Refer to 'DMA_LL_PAYLOAD_SPLIT' code in configureDMA() below to understand why this exists. + // numDMAdescriptorsPerRow is also used to calculate descount which is super important in i2s_parallel_config_t SoC DMA setup. + if (frame_buffer[0].rowBits[0]->size() > DMA_MAX) + { - numDMAdescriptorsPerRow += m_cfg.getPixelColorDepthBits()-1; - // Note: If numDMAdescriptorsPerRow is even just one descriptor too large, DMA linked list will not correctly loop. - } + ESP_LOGW("I2S-DMA", "rowBits struct is too large to fit in one DMA transfer payload, splitting required. Adding %d DMA descriptors\n", m_cfg.getPixelColorDepthBits() - 1); + numDMAdescriptorsPerRow += m_cfg.getPixelColorDepthBits() - 1; + // Note: If numDMAdescriptorsPerRow is even just one descriptor too large, DMA linked list will not correctly loop. + } /*** * Step 3: Allocate memory for DMA linked list, linking up each framebuffer row in sequence for GPIO output. - */ + */ - // malloc the DMA linked list descriptors that i2s_parallel will need - desccount = numDMAdescriptorsPerRow * ROWS_PER_FRAME; + // malloc the DMA linked list descriptors that i2s_parallel will need + desccount = numDMAdescriptorsPerRow * ROWS_PER_FRAME; - if (m_cfg.double_buff) - dma_bus.enable_double_dma_desc(); - - dma_bus.allocate_dma_desc_memory(desccount); + if (m_cfg.double_buff) + { + dma_bus.enable_double_dma_desc(); + } - // Just os we know - initialized = true; + dma_bus.allocate_dma_desc_memory(desccount); - return true; + // point FB we can write to, to 0 / dmadesc_a + fb = &frame_buffer[0]; -} // end allocateDMAmemory() + // Just os we know + initialized = true; + return true; +} // end allocateDMAmemory() -void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg) +void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG &_cfg) { - // lldesc_t *previous_dmadesc_a = 0; - // lldesc_t *previous_dmadesc_b = 0; - int current_dmadescriptor_offset = 0; + // lldesc_t *previous_dmadesc_a = 0; + // lldesc_t *previous_dmadesc_b = 0; + 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 = m_cfg.getPixelColorDepthBits(); + if (frame_buffer[0].rowBits[0]->size() > DMA_MAX) + { + num_dma_payload_colour_depths = 1; + } + + // Fill DMA linked lists for both frames (as in, halves of the HUB75 panel) and if double buffering is enabled, link it up for both buffers. + for (int row = 0; row < ROWS_PER_FRAME; row++) + { + // first set of data is LSB through MSB, single pass (IF TOTAL SIZE < DMA_MAX) - all colour bits are displayed once, which takes care of everything below and including LSBMSB_TRANSITION_BIT + // NOTE: size must be less than DMA_MAX - worst case for library: 16-bpp with 256 pixels per row would exceed this, need to break into two + // link_dma_desc(&dmadesc_a[current_dmadescriptor_offset], previous_dmadesc_a, dma_buff.rowBits[row]->getDataPtr(), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths)); + // previous_dmadesc_a = &dmadesc_a[current_dmadescriptor_offset]; + + dma_bus.create_dma_desc_link(frame_buffer[0].rowBits[row]->getDataPtr(0, 0), frame_buffer[0].rowBits[row]->size(1), false); - // 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 = m_cfg.getPixelColorDepthBits(); - if ( dma_buff.rowBits[0]->size() > DMA_MAX ) { - num_dma_payload_colour_depths = 1; + if (m_cfg.double_buff) + { + dma_bus.create_dma_desc_link(frame_buffer[1].rowBits[row]->getDataPtr(0, 1), frame_buffer[1].rowBits[row]->size(1), true); } - // Fill DMA linked lists for both frames (as in, halves of the HUB75 panel) and if double buffering is enabled, link it up for both buffers. - for(int row = 0; row < ROWS_PER_FRAME; row++) + current_dmadescriptor_offset++; + + // If the number of pixels per row is too great for the size of a DMA payload, so we need to split what we were going to send above. + if (frame_buffer[0].rowBits[0]->size() > DMA_MAX) { - // first set of data is LSB through MSB, single pass (IF TOTAL SIZE < DMA_MAX) - all colour bits are displayed once, which takes care of everything below and including LSBMSB_TRANSITION_BIT - // NOTE: size must be less than DMA_MAX - worst case for library: 16-bpp with 256 pixels per row would exceed this, need to break into two - //link_dma_desc(&dmadesc_a[current_dmadescriptor_offset], previous_dmadesc_a, dma_buff.rowBits[row]->getDataPtr(), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths)); - // previous_dmadesc_a = &dmadesc_a[current_dmadescriptor_offset]; - dma_bus.create_dma_desc_link( dma_buff.rowBits[row]->getDataPtr(0, 0), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths), false); + for (int cd = 1; cd < m_cfg.getPixelColorDepthBits(); cd++) + { + dma_bus.create_dma_desc_link(frame_buffer[0].rowBits[row]->getDataPtr(cd, 0), frame_buffer[0].rowBits[row]->size(1), false); - if (m_cfg.double_buff) + if (m_cfg.double_buff) { - dma_bus.create_dma_desc_link( dma_buff.rowBits[row]->getDataPtr(0, 1), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths), true); + dma_bus.create_dma_desc_link(frame_buffer[1].rowBits[row]->getDataPtr(cd, 1), frame_buffer[1].rowBits[row]->size(1), true); } current_dmadescriptor_offset++; - // If the number of pixels per row is too great for the size of a DMA payload, so we need to split what we were going to send above. - if ( dma_buff.rowBits[0]->size() > DMA_MAX ) + } // additional linked list items + } // row depth struct + + for (int i = lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); 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) + // we need 2^(i - LSBMSB_TRANSITION_BIT - 1) == 1 << (i - LSBMSB_TRANSITION_BIT - 1) passes from i to MSB + + for (int k = 0; k < (1 << (i - lsbMsbTransitionBit - 1)); k++) + { + dma_bus.create_dma_desc_link(frame_buffer[0].rowBits[row]->getDataPtr(i, 0), frame_buffer[0].rowBits[row]->size(1), false); + + if (m_cfg.double_buff) { - - for (int cd = 1; cd < m_cfg.getPixelColorDepthBits(); 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); + dma_bus.create_dma_desc_link(frame_buffer[1].rowBits[row]->getDataPtr(i, 1), frame_buffer[1].rowBits[row]->size(1), true); + } - if (m_cfg.double_buff) { - dma_bus.create_dma_desc_link(dma_buff.rowBits[row]->getDataPtr(cd, 1), dma_buff.rowBits[row]->size(num_dma_payload_colour_depths), true); - } + current_dmadescriptor_offset++; - current_dmadescriptor_offset++; + } // end colour depth ^ 2 linked list + } // end colour depth loop + + } // end frame rows + + ESP_LOGI("I2S-DMA", "%d DMA descriptors linked to buffer data.", current_dmadescriptor_offset); + + // + // Setup DMA and Output to GPIO + // + auto bus_cfg = dma_bus.config(); // バス設定用の構造体を取得します。 + + bus_cfg.bus_freq = m_cfg.i2sspeed; + bus_cfg.pin_wr = m_cfg.gpio.clk; // WR を接続しているピン番号 + + bus_cfg.pin_d0 = m_cfg.gpio.r1; + bus_cfg.pin_d1 = m_cfg.gpio.g1; + bus_cfg.pin_d2 = m_cfg.gpio.b1; + bus_cfg.pin_d3 = m_cfg.gpio.r2; + bus_cfg.pin_d4 = m_cfg.gpio.g2; + bus_cfg.pin_d5 = m_cfg.gpio.b2; + bus_cfg.pin_d6 = m_cfg.gpio.lat; + bus_cfg.pin_d7 = m_cfg.gpio.oe; + bus_cfg.pin_d8 = m_cfg.gpio.a; + bus_cfg.pin_d9 = m_cfg.gpio.b; + bus_cfg.pin_d10 = m_cfg.gpio.c; + bus_cfg.pin_d11 = m_cfg.gpio.d; + bus_cfg.pin_d12 = m_cfg.gpio.e; + bus_cfg.pin_d13 = -1; + bus_cfg.pin_d14 = -1; + bus_cfg.pin_d15 = -1; - } // additional linked list items - } // row depth struct +#if defined(SPIRAM_DMA_BUFFER) + bus_cfg.psram_clk_override = true; +#endif + dma_bus.config(bus_cfg); - for(int i=lsbMsbTransitionBit + 1; i < m_cfg.getPixelColorDepthBits(); 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) - // we need 2^(i - LSBMSB_TRANSITION_BIT - 1) == 1 << (i - LSBMSB_TRANSITION_BIT - 1) passes from i to MSB - - 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(m_cfg.getPixelColorDepthBits() - 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(m_cfg.getPixelColorDepthBits() - i), true ); - } - - current_dmadescriptor_offset++; - - } // end colour depth ^ 2 linked list - } // end colour depth loop - - } // end frame rows - - ESP_LOGI("I2S-DMA", "%d DMA descriptors linked to buffer data.", current_dmadescriptor_offset); - -// -// Setup DMA and Output to GPIO -// - auto bus_cfg = dma_bus.config(); // バス設定用の構造体を取得します。 - - bus_cfg.bus_freq = m_cfg.i2sspeed; - bus_cfg.pin_wr = m_cfg.gpio.clk; // WR を接続しているピン番号 - - bus_cfg.pin_d0 = m_cfg.gpio.r1; - bus_cfg.pin_d1 = m_cfg.gpio.g1; - bus_cfg.pin_d2 = m_cfg.gpio.b1; - bus_cfg.pin_d3 = m_cfg.gpio.r2; - bus_cfg.pin_d4 = m_cfg.gpio.g2; - bus_cfg.pin_d5 = m_cfg.gpio.b2; - bus_cfg.pin_d6 = m_cfg.gpio.lat; - bus_cfg.pin_d7 = m_cfg.gpio.oe; - bus_cfg.pin_d8 = m_cfg.gpio.a; - bus_cfg.pin_d9 = m_cfg.gpio.b; - bus_cfg.pin_d10 = m_cfg.gpio.c; - bus_cfg.pin_d11 = m_cfg.gpio.d; - bus_cfg.pin_d12 = m_cfg.gpio.e; - bus_cfg.pin_d13 = -1; - bus_cfg.pin_d14 = -1; - bus_cfg.pin_d15 = -1; - - #if defined(SPIRAM_DMA_BUFFER) - bus_cfg.psram_clk_override = true; - #endif - - dma_bus.config(bus_cfg); - - dma_bus.init(); - - dma_bus.dma_transfer_start(); - - flipDMABuffer(); // display back buffer 0, draw to 1, ignored if double buffering isn't enabled. - - //i2s_parallel_send_dma(ESP32_I2S_DEVICE, &dmadesc_a[0]); - ESP_LOGI("I2S-DMA", "DMA setup completed"); - -} // end initMatrixDMABuff + dma_bus.init(); + + dma_bus.dma_transfer_start(); + flipDMABuffer(); // display back buffer 0, draw to 1, ignored if double buffering isn't enabled. + + // i2s_parallel_send_dma(ESP32_I2S_DEVICE, &dmadesc_a[0]); + ESP_LOGI("I2S-DMA", "DMA setup completed"); + +} // end initMatrixDMABuff /* There are 'bits' set in the frameStruct that we simply don't need to set every single time we change a pixel / DMA buffer co-ordinate. * For example, the bits that determine the address lines, we don't need to set these every time. Once they're in place, and assuming we @@ -295,448 +305,386 @@ void MatrixPanel_I2S_DMA::configureDMA(const HUB75_I2S_CFG& _cfg) * Let's put it into IRAM to avoid situations when it could be flushed out of instruction cache * and had to be read from spi-flash over and over again. * Yes, it is always a tradeoff between memory/speed/size, but compared to DMA-buffer size is not a big deal - * + * * Note: Cannot pass a negative co-ord as it makes no sense in the DMA bit array lookup. */ void IRAM_ATTR MatrixPanel_I2S_DMA::updateMatrixDMABuffer(uint16_t x_coord, uint16_t y_coord, uint8_t red, uint8_t green, uint8_t blue) { - if ( !initialized ) return; + if (!initialized) + return; /* 1) Check that the co-ordinates are within range, or it'll break everything big time. - * Valid co-ordinates are from 0 to (MATRIX_XXXX-1) - */ - if ( x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) { + * Valid co-ordinates are from 0 to (MATRIX_XXXX-1) + */ + if (x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) + { return; } - /* 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 colour is exactly '1' + /* 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 colour is exactly '1' * https://ledshield.wordpress.com/2012/11/13/led-brightness-to-your-eye-gamma-correction-no/ - */ -uint16_t red16, green16, blue16; + */ + uint16_t red16, green16, blue16; #ifndef NO_CIE1931 - red16 = lumConvTab[red]; - green16 = lumConvTab[green]; - blue16 = lumConvTab[blue]; + red16 = lumConvTab[red]; + green16 = lumConvTab[green]; + blue16 = lumConvTab[blue]; #else - red16 = red << 8; - green16 = green << 8; - blue16 = blue << 8; + red16 = red << 8; + green16 = green << 8; + blue16 = blue << 8; #endif - /* When using the drawPixel, we are obviously only changing the value of one x,y position, - * however, the two-scan panels paint TWO lines at the same time - * and this reflects the parallel in-DMA-memory data structure of uint16_t's that are getting - * pumped out at high speed. - * - * So we need to ensure we persist the bits (8 of them) of the uint16_t for the row we aren't changing. - * - * The DMA buffer order has also been reversed (refer to the last code in this function) - * so we have to check for this and check the correct position of the MATRIX_DATA_STORAGE_TYPE - * data. - */ - x_coord = ESP32_TX_FIFO_POSITION_ADJUST(x_coord); - - - uint16_t _colourbitclear = BITMASK_RGB1_CLEAR, _colourbitoffset = 0; - - if (y_coord >= ROWS_PER_FRAME){ // if we are drawing to the bottom part of the panel - _colourbitoffset = BITS_RGB2_OFFSET; - _colourbitclear = BITMASK_RGB2_CLEAR; - y_coord -= ROWS_PER_FRAME; - } + /* When using the drawPixel, we are obviously only changing the value of one x,y position, + * however, the two-scan panels paint TWO lines at the same time + * and this reflects the parallel in-DMA-memory data structure of uint16_t's that are getting + * pumped out at high speed. + * + * So we need to ensure we persist the bits (8 of them) of the uint16_t for the row we aren't changing. + * + * The DMA buffer order has also been reversed (refer to the last code in this function) + * so we have to check for this and check the correct position of the MATRIX_DATA_STORAGE_TYPE + * data. + */ + x_coord = ESP32_TX_FIFO_POSITION_ADJUST(x_coord); - // Iterating through colour depth bits, which we assume are 8 bits per RGB subpixel (24bpp) - uint8_t colour_depth_idx = m_cfg.getPixelColorDepthBits(); - do { - --colour_depth_idx; - - uint16_t mask = PIXEL_COLOR_MASK_BIT(colour_depth_idx, MASK_OFFSET); - uint16_t RGB_output_bits = 0; + uint16_t _colourbitclear = BITMASK_RGB1_CLEAR, _colourbitoffset = 0; - /* Per the .h file, the order of the output RGB bits is: - * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ - RGB_output_bits |= (bool)(blue16 & mask); // --B - RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(green16 & mask); // -BG - RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(red16 & mask); // BGR - RGB_output_bits <<= _colourbitoffset; // shift colour bits to the required position + if (y_coord >= ROWS_PER_FRAME) + { // if we are drawing to the bottom part of the panel + _colourbitoffset = BITS_RGB2_OFFSET; + _colourbitclear = BITMASK_RGB2_CLEAR; + y_coord -= ROWS_PER_FRAME; + } + // Iterating through colour depth bits, which we assume are 8 bits per RGB subpixel (24bpp) + uint8_t colour_depth_idx = m_cfg.getPixelColorDepthBits(); + do + { + --colour_depth_idx; + + uint16_t mask = PIXEL_COLOR_MASK_BIT(colour_depth_idx, MASK_OFFSET); + uint16_t RGB_output_bits = 0; - // Get the contents at this address, - // 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); + /* Per the .h file, the order of the output RGB bits is: + * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ + RGB_output_bits |= (bool)(blue16 & mask); // --B + RGB_output_bits <<= 1; + RGB_output_bits |= (bool)(green16 & mask); // -BG + RGB_output_bits <<= 1; + RGB_output_bits |= (bool)(red16 & mask); // BGR + RGB_output_bits <<= _colourbitoffset; // shift colour 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 colour depth bit at Y coordinate + ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(y_coord, colour_depth_idx, back_buffer_id); - // We need to update the correct uint16_t word in the rowBitStruct array pointing to a specific pixel at X - coordinate - p[x_coord] &= _colourbitclear; // reset RGB bits - p[x_coord] |= RGB_output_bits; // set new RGB bits + // We need to update the correct uint16_t word in the rowBitStruct array pointing to a specific pixel at X - coordinate + p[x_coord] &= _colourbitclear; // reset RGB bits + p[x_coord] |= RGB_output_bits; // set new RGB bits - #if defined(SPIRAM_DMA_BUFFER) - Cache_WriteBack_Addr((uint32_t)&p[x_coord], sizeof(ESP32_I2S_DMA_STORAGE_TYPE)) ; - #endif +#if defined(SPIRAM_DMA_BUFFER) + Cache_WriteBack_Addr((uint32_t)&p[x_coord], sizeof(ESP32_I2S_DMA_STORAGE_TYPE)); +#endif - } while(colour_depth_idx); // end of colour depth loop (8) + } while (colour_depth_idx); // end of colour depth loop (8) } // updateMatrixDMABuffer (specific co-ords change) - /* Update the entire buffer with a single specific colour - quicker */ void MatrixPanel_I2S_DMA::updateMatrixDMABuffer(uint8_t red, uint8_t green, uint8_t blue) { - if ( !initialized ) return; - - /* https://ledshield.wordpress.com/2012/11/13/led-brightness-to-your-eye-gamma-correction-no/ */ -uint16_t red16, green16, blue16; + if (!initialized) + return; + + /* https://ledshield.wordpress.com/2012/11/13/led-brightness-to-your-eye-gamma-correction-no/ */ + uint16_t red16, green16, blue16; #ifndef NO_CIE1931 - red16 = lumConvTab[red]; - green16 = lumConvTab[green]; - blue16 = lumConvTab[blue]; + red16 = lumConvTab[red]; + green16 = lumConvTab[green]; + blue16 = lumConvTab[blue]; #else - red16 = red << 8; - green16 = green << 8; - blue16 = blue << 8; + red16 = red << 8; + green16 = green << 8; + blue16 = blue << 8; #endif - for(uint8_t colour_depth_idx=0; colour_depth_idx < m_cfg.getPixelColorDepthBits(); colour_depth_idx++) // colour depth - 8 iterations + for (uint8_t colour_depth_idx = 0; colour_depth_idx < m_cfg.getPixelColorDepthBits(); 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; + uint16_t RGB_output_bits = 0; uint16_t mask = PIXEL_COLOR_MASK_BIT(colour_depth_idx, MASK_OFFSET); /* Per the .h file, the order of the output RGB bits is: * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ - RGB_output_bits |= (bool)(blue16 & mask); // --B + RGB_output_bits |= (bool)(blue16 & mask); // --B RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(green16 & mask); // -BG + RGB_output_bits |= (bool)(green16 & mask); // -BG RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(red16 & mask); // BGR - + RGB_output_bits |= (bool)(red16 & mask); // BGR + // Duplicate and shift across so we have have 6 populated bits of RGB1 and RGB2 pin values suitable for DMA buffer - RGB_output_bits |= RGB_output_bits << BITS_RGB2_OFFSET; //BGRBGR - - //Serial.printf("Fill with: 0x%#06x\n", RGB_output_bits); + RGB_output_bits |= RGB_output_bits << BITS_RGB2_OFFSET; // BGRBGR + + // Serial.printf("Fill with: 0x%#06x\n", RGB_output_bits); // iterate rows - int matrix_frame_parallel_row = dma_buff.rowBits.size(); - do { + int matrix_frame_parallel_row = fb->rowBits.size(); + do + { --matrix_frame_parallel_row; // The destination for the pixel row bitstream ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(matrix_frame_parallel_row, colour_depth_idx, back_buffer_id); // iterate pixels in a row - int x_coord=dma_buff.rowBits[matrix_frame_parallel_row]->width; - do { + int x_coord = fb->rowBits[matrix_frame_parallel_row]->width; + do + { --x_coord; - p[x_coord] &= BITMASK_RGB12_CLEAR; // reset colour bits - p[x_coord] |= RGB_output_bits; // set new colour bits + p[x_coord] &= BITMASK_RGB12_CLEAR; // reset colour bits + p[x_coord] |= RGB_output_bits; // set new colour bits +#if defined(SPIRAM_DMA_BUFFER) + Cache_WriteBack_Addr((uint32_t)&p[x_coord], sizeof(ESP32_I2S_DMA_STORAGE_TYPE)); +#endif - #if defined(SPIRAM_DMA_BUFFER) - Cache_WriteBack_Addr((uint32_t)&p[x_coord], sizeof(ESP32_I2S_DMA_STORAGE_TYPE)) ; - #endif - - } while(x_coord); + } while (x_coord); - } while(matrix_frame_parallel_row); // end row iteration - } // colour depth loop (8) + } while (matrix_frame_parallel_row); // end row iteration + } // colour depth loop (8) } // updateMatrixDMABuffer (full frame paint) /** * @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 colour data - * so we could set it once on DMA buffs initialization and forget. + * 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) - this must be done as well seperately! */ -void MatrixPanel_I2S_DMA::clearFrameBuffer(bool _buff_id){ +void MatrixPanel_I2S_DMA::clearFrameBuffer(bool _buff_id) +{ if (!initialized) return; // we start with iterating all rows in dma_buff structure - int row_idx = dma_buff.rowBits.size(); - do { + int row_idx = fb->rowBits.size(); + do + { --row_idx; - - ESP32_I2S_DMA_STORAGE_TYPE* row = dma_buff.rowBits[row_idx]->getDataPtr(0, _buff_id); // set pointer to the HEAD of a buffer holding data for the entire matrix row + + ESP32_I2S_DMA_STORAGE_TYPE *row = fb->rowBits[row_idx]->getDataPtr(0, _buff_id); // set pointer to the HEAD of a buffer holding data for the entire matrix row ESP32_I2S_DMA_STORAGE_TYPE abcde = (ESP32_I2S_DMA_STORAGE_TYPE)row_idx; - abcde <<= BITS_ADDR_OFFSET; // shift row y-coord to match ABCDE bits in vector from 8 to 12 + abcde <<= BITS_ADDR_OFFSET; // shift row y-coord to match ABCDE bits in vector from 8 to 12 // get last pixel index in a row of all colourdepths - int x_pixel = dma_buff.rowBits[row_idx]->width * dma_buff.rowBits[row_idx]->colour_depth; - //Serial.printf(" from pixel %d, ", x_pixel); + int x_pixel = fb->rowBits[row_idx]->width * fb->rowBits[row_idx]->colour_depth; + // Serial.printf(" from pixel %d, ", x_pixel); // fill all x_pixels except colour_index[0] (LSB) ones, this also clears all colour data to 0's black - do { + do + { --x_pixel; - - if ( m_cfg.driver == HUB75_I2S_CFG::SM5266P) { - // modifications here for row shift register type SM5266P + + if (m_cfg.driver == HUB75_I2S_CFG::SM5266P) + { + // modifications here for row shift register type SM5266P // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA/issues/164 - row[x_pixel] = abcde & (0x18 << BITS_ADDR_OFFSET); // mask out the bottom 3 bits which are the clk di bk inputs - } else { + row[x_pixel] = abcde & (0x18 << BITS_ADDR_OFFSET); // mask out the bottom 3 bits which are the clk di bk inputs + } + else + { row[ESP32_TX_FIFO_POSITION_ADJUST(x_pixel)] = abcde; } - } while(x_pixel!=dma_buff.rowBits[row_idx]->width && x_pixel); + } while (x_pixel != fb->rowBits[row_idx]->width && x_pixel); // colour_index[0] (LSB) x_pixels must be "marked" with a previous's row address, 'cause it is used to display // previous row while we pump in LSB's for a new row - abcde = ((ESP32_I2S_DMA_STORAGE_TYPE)row_idx-1) << BITS_ADDR_OFFSET; - do { + abcde = ((ESP32_I2S_DMA_STORAGE_TYPE)row_idx - 1) << BITS_ADDR_OFFSET; + do + { --x_pixel; - - if ( m_cfg.driver == HUB75_I2S_CFG::SM5266P) { - // modifications here for row shift register type SM5266P + + if (m_cfg.driver == HUB75_I2S_CFG::SM5266P) + { + // modifications here for row shift register type SM5266P // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA/issues/164 - row[x_pixel] = abcde & (0x18 << BITS_ADDR_OFFSET); // mask out the bottom 3 bits which are the clk di bk inputs - } else { + row[x_pixel] = abcde & (0x18 << BITS_ADDR_OFFSET); // mask out the bottom 3 bits which are the clk di bk inputs + } + else + { row[ESP32_TX_FIFO_POSITION_ADJUST(x_pixel)] = abcde; - } - - } while(x_pixel); - - - // modifications here for row shift register type SM5266P - // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA/issues/164 - if ( m_cfg.driver == HUB75_I2S_CFG::SM5266P) { - uint16_t serialCount; - uint16_t latch; - x_pixel = dma_buff.rowBits[row_idx]->width - 16; // come back 8*2 pixels to allow for 8 writes - serialCount = 8; - do{ - serialCount--; - latch = row[x_pixel] | (((((ESP32_I2S_DMA_STORAGE_TYPE)row_idx) % 8) == serialCount) << 1) << BITS_ADDR_OFFSET; // data on 'B' - row[x_pixel++] = latch| (0x05<< BITS_ADDR_OFFSET); // clock high on 'A'and BK high for update - row[x_pixel++] = latch| (0x04<< BITS_ADDR_OFFSET); // clock low on 'A'and BK high for update - } while (serialCount); - } // end SM5266P - - - // 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 colour index - row = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id); - - row[ESP32_TX_FIFO_POSITION_ADJUST(dma_buff.rowBits[row_idx]->width - 1)] |= BIT_LAT; // -1 pixel to compensate array index starting at 0 - - //ESP32_TX_FIFO_POSITION_ADJUST(dma_buff.rowBits[row_idx]->width - 1) - - // need to disable OE before/after latch to hide row transition - // Should be one clock or more before latch, otherwise can get ghosting - uint8_t _blank = m_cfg.latch_blanking; - do { - --_blank; - - row[ESP32_TX_FIFO_POSITION_ADJUST(0 + _blank)] |= BIT_OE; // disable output - row[ESP32_TX_FIFO_POSITION_ADJUST(dma_buff.rowBits[row_idx]->width - 1)] |= BIT_OE; // disable output - row[ESP32_TX_FIFO_POSITION_ADJUST(dma_buff.rowBits[row_idx]->width - _blank - 1)] |= BIT_OE; // (LAT pulse is (width-2) -1 pixel to compensate array index starting at 0 - - - } while (_blank); - - } while(colouridx); - - - - #if defined(SPIRAM_DMA_BUFFER) - Cache_WriteBack_Addr((uint32_t)row, sizeof(ESP32_I2S_DMA_STORAGE_TYPE) * ((dma_buff.rowBits[row_idx]->width * dma_buff.rowBits[row_idx]->colour_depth)-1)) ; - #endif - - - } while(row_idx); -} - -/** - * @brief - reset OE bits in DMA buffer in a way to control brightness - * @param brt - brightness level from 0 to row_width - * @param _buff_id - buffer id to control - */ -/* -// Depreciated -void MatrixPanel_I2S_DMA::brtCtrlOE(int brt, const bool _buff_id){ - - if (!initialized) - return; - - if (brt > PIXELS_PER_ROW - (MAX_LAT_BLANKING + 2)) // can't control values larger than (row_width - latch_blanking) to avoid ongoing issues being raised about brightness and ghosting. - brt = PIXELS_PER_ROW - (MAX_LAT_BLANKING + 2); // +2 for a bit of buffer... + } - if (brt < 0) - brt = 0; + } while (x_pixel); - // start with iterating all rows in dma_buff structure - int row_idx = dma_buff.rowBits.size(); - do { - --row_idx; + // modifications here for row shift register type SM5266P + // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA/issues/164 + if (m_cfg.driver == HUB75_I2S_CFG::SM5266P) + { + uint16_t serialCount; + uint16_t latch; + x_pixel = fb->rowBits[row_idx]->width - 16; // come back 8*2 pixels to allow for 8 writes + serialCount = 8; + do + { + serialCount--; + latch = row[x_pixel] | (((((ESP32_I2S_DMA_STORAGE_TYPE)row_idx) % 8) == serialCount) << 1) << BITS_ADDR_OFFSET; // data on 'B' + row[x_pixel++] = latch | (0x05 << BITS_ADDR_OFFSET); // clock high on 'A'and BK high for update + row[x_pixel++] = latch | (0x04 << BITS_ADDR_OFFSET); // clock low on 'A'and BK high for update + } while (serialCount); + } // end SM5266P - // 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 { + // 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 = fb->rowBits[row_idx]->colour_depth; + do + { --colouridx; // 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; - do { - --x_coord; - - // clear OE bit for all other pixels - row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] &= BITMASK_OE_CLEAR; + row = fb->rowBits[row_idx]->getDataPtr(colouridx, _buff_id); - // Brightness control via OE toggle - disable matrix output at specified x_coord - if((colouridx > lsbMsbTransitionBit || !colouridx) && ((x_coord) >= brt)){ - row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] |= BIT_OE; // Disable output after this point. - continue; - } - // special case for the bits *after* LSB through (lsbMsbTransitionBit) - OE is output after data is shifted, so need to set OE to fractional brightness - if(colouridx && colouridx <= lsbMsbTransitionBit) { - // divide brightness in half for each bit below lsbMsbTransitionBit - int lsbBrightness = brt >> (lsbMsbTransitionBit - colouridx + 1); - if((x_coord) >= lsbBrightness) { - row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] |= BIT_OE; // Disable output after this point. - continue; - } - } + row[ESP32_TX_FIFO_POSITION_ADJUST(fb->rowBits[row_idx]->width - 1)] |= BIT_LAT; // -1 pixel to compensate array index starting at 0 - - } while(x_coord); + // ESP32_TX_FIFO_POSITION_ADJUST(dma_buff.rowBits[row_idx]->width - 1) // need to disable OE before/after latch to hide row transition // Should be one clock or more before latch, otherwise can get ghosting uint8_t _blank = m_cfg.latch_blanking; - do { + do + { --_blank; + row[ESP32_TX_FIFO_POSITION_ADJUST(0 + _blank)] |= BIT_OE; // disable output + row[ESP32_TX_FIFO_POSITION_ADJUST(fb->rowBits[row_idx]->width - 1)] |= BIT_OE; // disable output + row[ESP32_TX_FIFO_POSITION_ADJUST(fb->rowBits[row_idx]->width - _blank - 1)] |= BIT_OE; // (LAT pulse is (width-2) -1 pixel to compensate array index starting at 0 - row[ESP32_TX_FIFO_POSITION_ADJUST(0 + _blank)] |= BIT_OE; - - - - //row[0 + _blank] |= BIT_OE; - // no need, has been done already - //row[dma_buff.rowBits[row_idx]->width - _blank - 3 ] |= BIT_OE; // (LAT pulse is (width-2) -1 pixel to compensate array index starting at 0 } while (_blank); - } while(colouridx); - - // 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)) ; - #endif + } while (colouridx); +#if defined(SPIRAM_DMA_BUFFER) + Cache_WriteBack_Addr((uint32_t)row, sizeof(ESP32_I2S_DMA_STORAGE_TYPE) * ((fb->rowBits[row_idx]->width * fb->rowBits[row_idx]->colour_depth) - 1)); +#endif - } while(row_idx); + } while (row_idx); } - */ - /** * @brief - reset OE bits in DMA buffer in a way to control brightness * @param brt - brightness level from 0 to 255 - NOT MATRIX_WIDTH * @param _buff_id - buffer id to control */ -void MatrixPanel_I2S_DMA::brtCtrlOEv2(uint8_t brt, const int _buff_id) { - +void MatrixPanel_I2S_DMA::brtCtrlOEv2(uint8_t brt, const int _buff_id) +{ + if (!initialized) return; - uint8_t _blank = m_cfg.latch_blanking; // don't want to inadvertantly blast over this - uint8_t _depth = dma_buff.rowBits[0]->colour_depth; - uint16_t _width = dma_buff.rowBits[0]->width; + uint8_t _blank = m_cfg.latch_blanking; // don't want to inadvertantly blast over this + uint8_t _depth = fb->rowBits[0]->colour_depth; + uint16_t _width = fb->rowBits[0]->width; // start with iterating all rows in dma_buff structure - int row_idx = dma_buff.rowBits.size(); - do { + int row_idx = fb->rowBits.size(); + do + { --row_idx; // let's set OE control bits for specific pixels in each color_index subrows uint8_t colouridx = _depth; - do { + do + { --colouridx; - - char bitplane = ( 2 * _depth - colouridx ) % _depth; - char bitshift = (_depth - lsbMsbTransitionBit - 1) >> 1; - - char rightshift = std::max( bitplane - bitshift - 2, 0 ); + + char bitplane = (2 * _depth - colouridx) % _depth; + char bitshift = (_depth - lsbMsbTransitionBit - 1) >> 1; + + char rightshift = std::max(bitplane - bitshift - 2, 0); // calculate the OE disable period by brightness, and also blanking - int brightness_in_x_pixels = ( ( _width - _blank ) * brt ) >> ( 7 + rightshift ); - brightness_in_x_pixels = ( brightness_in_x_pixels >> 1 ) | ( brightness_in_x_pixels & 1 ); - + int brightness_in_x_pixels = ((_width - _blank) * brt) >> (7 + rightshift); + brightness_in_x_pixels = (brightness_in_x_pixels >> 1) | (brightness_in_x_pixels & 1); + // switch pointer to a row for a specific color index - ESP32_I2S_DMA_STORAGE_TYPE* row = dma_buff.rowBits[row_idx]->getDataPtr(colouridx, _buff_id); + ESP32_I2S_DMA_STORAGE_TYPE *row = fb->rowBits[row_idx]->getDataPtr(colouridx, _buff_id); // define range of Output Enable on the center of the row - int x_coord_max = ( _width + brightness_in_x_pixels + 1 ) >> 1; - int x_coord_min = ( _width - brightness_in_x_pixels + 0 ) >> 1; + int x_coord_max = (_width + brightness_in_x_pixels + 1) >> 1; + int x_coord_min = (_width - brightness_in_x_pixels + 0) >> 1; int x_coord = _width; - do { + do + { --x_coord; - + // (the check is already including "blanking" ) - if (x_coord >= x_coord_min && x_coord < x_coord_max) - { - row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] &= BITMASK_OE_CLEAR; - } - else - { - row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] |= BIT_OE; // Disable output after this point. - } - - } while(x_coord); - - } while(colouridx); - - // 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)) ; - #endif - } while(row_idx); - -} + if (x_coord >= x_coord_min && x_coord < x_coord_max) + { + row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] &= BITMASK_OE_CLEAR; + } + else + { + row[ESP32_TX_FIFO_POSITION_ADJUST(x_coord)] |= BIT_OE; // Disable output after this point. + } + + } while (x_coord); + } while (colouridx); + +// switch pointer to a row for a specific colour index +#if defined(SPIRAM_DMA_BUFFER) + ESP32_I2S_DMA_STORAGE_TYPE *row_hack = fb->rowBits[row_idx]->getDataPtr(colouridx, _buff_id); + Cache_WriteBack_Addr((uint32_t)row_hack, sizeof(ESP32_I2S_DMA_STORAGE_TYPE) * ((fb->rowBits[row_idx]->width * fb->rowBits[row_idx]->colour_depth) - 1)); +#endif + } while (row_idx); +} /* * overload for compatibility */ - -bool MatrixPanel_I2S_DMA::begin(int r1, int g1, int b1, int r2, int g2, int b2, int a, int b, int c, int d, int e, int lat, int oe, int clk) { - if(initialized) return true; + +bool MatrixPanel_I2S_DMA::begin(int r1, int g1, int b1, int r2, int g2, int b2, int a, int b, int c, int d, int e, int lat, int oe, int clk) +{ + if (initialized) + return true; // RGB - m_cfg.gpio.r1 = r1; m_cfg.gpio.g1 = g1; m_cfg.gpio.b1 = b1; - m_cfg.gpio.r2 = r2; m_cfg.gpio.g2 = g2; m_cfg.gpio.b2 = b2; - + m_cfg.gpio.r1 = r1; + m_cfg.gpio.g1 = g1; + m_cfg.gpio.b1 = b1; + m_cfg.gpio.r2 = r2; + m_cfg.gpio.g2 = g2; + m_cfg.gpio.b2 = b2; + // Line Select - m_cfg.gpio.a = a; m_cfg.gpio.b = b; m_cfg.gpio.c = c; - m_cfg.gpio.d = d; m_cfg.gpio.e = e; - + m_cfg.gpio.a = a; + m_cfg.gpio.b = b; + m_cfg.gpio.c = c; + m_cfg.gpio.d = d; + m_cfg.gpio.e = e; + // Clock & Control - m_cfg.gpio.lat = lat; m_cfg.gpio.oe = oe; m_cfg.gpio.clk = clk; + m_cfg.gpio.lat = lat; + m_cfg.gpio.oe = oe; + m_cfg.gpio.clk = clk; return begin(); } -bool MatrixPanel_I2S_DMA::begin(const HUB75_I2S_CFG& cfg){ - if(initialized) return true; +bool MatrixPanel_I2S_DMA::begin(const HUB75_I2S_CFG &cfg) +{ + if (initialized) + return true; - if(!setCfg(cfg)) return false; + if (!setCfg(cfg)) + return false; return begin(); -} - - +} /** * @brief - Sets how many clock cycles to blank OE before/after LAT signal change @@ -745,7 +693,8 @@ bool MatrixPanel_I2S_DMA::begin(const HUB75_I2S_CFG& cfg){ * Max is MAX_LAT_BLANKING * @returns - new value for m_cfg.latch_blanking */ -uint8_t MatrixPanel_I2S_DMA::setLatBlanking(uint8_t pulses){ +uint8_t MatrixPanel_I2S_DMA::setLatBlanking(uint8_t pulses) +{ if (pulses > MAX_LAT_BLANKING) pulses = MAX_LAT_BLANKING; @@ -753,13 +702,12 @@ uint8_t MatrixPanel_I2S_DMA::setLatBlanking(uint8_t pulses){ pulses = DEFAULT_LAT_BLANKING; m_cfg.latch_blanking = pulses; - + // remove brightness var for now. - //setPanelBrightness(brightness); // set brightness to reset OE bits to the values matching new LAT blanking setting + // setPanelBrightness(brightness); // set brightness to reset OE bits to the values matching new LAT blanking setting return m_cfg.latch_blanking; } - #ifndef NO_FAST_FUNCTIONS /** * @brief - update DMA buff drawing horizontal line at specified coordinates @@ -768,94 +716,96 @@ uint8_t MatrixPanel_I2S_DMA::setLatBlanking(uint8_t pulses){ * @param l - line length * @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 ) +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) return; - if ( (x_coord + l) < 1 || y_coord < 0 || l < 1 || x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) + if ((x_coord + l) < 1 || y_coord < 0 || l < 1 || x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) return; - l = x_coord < 0 ? l+x_coord : l; + l = x_coord < 0 ? l + x_coord : l; x_coord = x_coord < 0 ? 0 : x_coord; + l = ((x_coord + l) >= PIXELS_PER_ROW) ? (PIXELS_PER_ROW - x_coord) : l; - l = ( (x_coord + l) >= PIXELS_PER_ROW ) ? (PIXELS_PER_ROW - x_coord):l; - - //if (x_coord+l > PIXELS_PER_ROW) -// l = PIXELS_PER_ROW - x_coord + 1; // reset width to end of row + // if (x_coord+l > PIXELS_PER_ROW) + // l = PIXELS_PER_ROW - x_coord + 1; // reset width to end of row /* LED Brightness Compensation */ -uint16_t red16, green16, blue16; + uint16_t red16, green16, blue16; #ifndef NO_CIE1931 - red16 = lumConvTab[red]; - green16 = lumConvTab[green]; - blue16 = lumConvTab[blue]; + red16 = lumConvTab[red]; + green16 = lumConvTab[green]; + blue16 = lumConvTab[blue]; #else - red16 = red << 8; - green16 = green << 8; - blue16 = blue << 8; + red16 = red << 8; + green16 = green << 8; + blue16 = blue << 8; #endif uint16_t _colourbitclear = BITMASK_RGB1_CLEAR, _colourbitoffset = 0; - if (y_coord >= ROWS_PER_FRAME){ // if we are drawing to the bottom part of the panel + if (y_coord >= ROWS_PER_FRAME) + { // if we are drawing to the bottom part of the panel _colourbitoffset = BITS_RGB2_OFFSET; - _colourbitclear = BITMASK_RGB2_CLEAR; + _colourbitclear = BITMASK_RGB2_CLEAR; y_coord -= ROWS_PER_FRAME; } // Iterating through colour depth bits (8 iterations) uint8_t colour_depth_idx = m_cfg.getPixelColorDepthBits(); - do { + 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); + // uint8_t mask = (1 << colour_depth_idx COLOR_DEPTH_LESS_THAN_8BIT_ADJUST); // #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 + // #endif uint16_t mask = PIXEL_COLOR_MASK_BIT(colour_depth_idx, MASK_OFFSET); /* Per the .h file, the order of the output RGB bits is: - * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ - RGB_output_bits |= (bool)(blue16 & mask); // --B + * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ + RGB_output_bits |= (bool)(blue16 & mask); // --B RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(green16 & mask); // -BG + RGB_output_bits |= (bool)(green16 & mask); // -BG RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(red16 & mask); // BGR - RGB_output_bits <<= _colourbitoffset; // shift color bits to the required position + RGB_output_bits |= (bool)(red16 & mask); // BGR + 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 colour depth bit at Y coordinate - ESP32_I2S_DMA_STORAGE_TYPE *p = dma_buff.rowBits[y_coord]->getDataPtr(colour_depth_idx, back_buffer_id); + ESP32_I2S_DMA_STORAGE_TYPE *p = fb->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); int16_t _l = l; - do { // iterate pixels in a row - int16_t _x = x_coord + --_l; - - /* - #if defined(ESP32_THE_ORIG) - // Save the calculated value to the bitplane memory in reverse order to account for I2S Tx FIFO mode1 ordering - uint16_t &v = p[_x & 1U ? --_x : ++_x]; - #else - // ESP 32 doesn't need byte flipping for TX FIFO. - uint16_t &v = p[_x]; - #endif - */ - uint16_t &v = p[ESP32_TX_FIFO_POSITION_ADJUST(_x)]; - - 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 colour depth loop (8) + do + { // iterate pixels in a row + int16_t _x = x_coord + --_l; + + /* + #if defined(ESP32_THE_ORIG) + // Save the calculated value to the bitplane memory in reverse order to account for I2S Tx FIFO mode1 ordering + uint16_t &v = p[_x & 1U ? --_x : ++_x]; + #else + // ESP 32 doesn't need byte flipping for TX FIFO. + uint16_t &v = p[_x]; + #endif + */ + uint16_t &v = p[ESP32_TX_FIFO_POSITION_ADJUST(_x)]; + + 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 colour depth loop (8) } // hlineDMA() - /** * @brief - update DMA buff drawing vertical line at specified coordinates * @param x_coord - line start coordinate x @@ -863,87 +813,90 @@ uint16_t red16, green16, blue16; * @param l - line length * @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 ) +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) return; - if ( x_coord < 0 || (y_coord + l) < 1 || l < 1 || x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) + if (x_coord < 0 || (y_coord + l) < 1 || l < 1 || x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) return; - l = y_coord < 0 ? l+y_coord : l; + l = y_coord < 0 ? l + y_coord : l; y_coord = y_coord < 0 ? 0 : y_coord; // check for a length that goes beyond the height of the screen! Array out of bounds dma memory changes = screwed output #163 - l = ( (y_coord + l) >= m_cfg.mx_height ) ? (m_cfg.mx_height - y_coord):l; - //if (y_coord + l > m_cfg.mx_height) + l = ((y_coord + l) >= m_cfg.mx_height) ? (m_cfg.mx_height - y_coord) : l; + // if (y_coord + l > m_cfg.mx_height) /// l = m_cfg.mx_height - y_coord + 1; // reset width to end of col /* LED Brightness Compensation */ -uint16_t red16, green16, blue16; + uint16_t red16, green16, blue16; #ifndef NO_CIE1931 - red16 = lumConvTab[red]; - green16 = lumConvTab[green]; - blue16 = lumConvTab[blue]; + red16 = lumConvTab[red]; + green16 = lumConvTab[green]; + blue16 = lumConvTab[blue]; #else - red16 = red << 8; - green16 = green << 8; - blue16 = blue << 8; + red16 = red << 8; + green16 = green << 8; + blue16 = blue << 8; #endif -/* -#if defined(ESP32_THE_ORIG) - // Save the calculated value to the bitplane memory in reverse order to account for I2S Tx FIFO mode1 ordering - x_coord & 1U ? --x_coord : ++x_coord; -#endif -*/ + /* + #if defined(ESP32_THE_ORIG) + // Save the calculated value to the bitplane memory in reverse order to account for I2S Tx FIFO mode1 ordering + x_coord & 1U ? --x_coord : ++x_coord; + #endif + */ x_coord = ESP32_TX_FIFO_POSITION_ADJUST(x_coord); uint8_t colour_depth_idx = m_cfg.getPixelColorDepthBits(); - do { // Iterating through colour depth bits (8 iterations) + 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); + // uint8_t mask = (1 << colour_depth_idx COLOR_DEPTH_LESS_THAN_8BIT_ADJUST); // #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 + // #endif uint16_t mask = PIXEL_COLOR_MASK_BIT(colour_depth_idx, MASK_OFFSET); uint16_t RGB_output_bits = 0; /* Per the .h file, the order of the output RGB bits is: - * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ - RGB_output_bits |= (bool)(blue16 & mask); // --B + * BIT_B2, BIT_G2, BIT_R2, BIT_B1, BIT_G1, BIT_R1 */ + RGB_output_bits |= (bool)(blue16 & mask); // --B RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(green16 & mask); // -BG + RGB_output_bits |= (bool)(green16 & mask); // -BG RGB_output_bits <<= 1; - RGB_output_bits |= (bool)(red16 & mask); // BGR + RGB_output_bits |= (bool)(red16 & mask); // BGR int16_t _l = 0, _y = y_coord; uint16_t _colourbitclear = BITMASK_RGB1_CLEAR; - do { // iterate pixels in a column + do + { // iterate pixels in a column - if (_y >= ROWS_PER_FRAME){ // if y-coord overlapped bottom-half panel + if (_y >= ROWS_PER_FRAME) + { // if y-coord overlapped bottom-half panel _y -= ROWS_PER_FRAME; - _colourbitclear = BITMASK_RGB2_CLEAR; + _colourbitclear = BITMASK_RGB2_CLEAR; RGB_output_bits <<= BITS_RGB2_OFFSET; } // Get the contents at this address, // 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); + // ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(_y, colour_depth_idx, back_buffer_id); + ESP32_I2S_DMA_STORAGE_TYPE *p = fb->rowBits[_y]->getDataPtr(colour_depth_idx, back_buffer_id); - p[x_coord] &= _colourbitclear; // reset RGB bits - p[x_coord] |= RGB_output_bits; // set new RGB bits + p[x_coord] &= _colourbitclear; // reset RGB bits + 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 colour depth loop (8) + } while (++_l != l); // iterate pixels in a col + } while (colour_depth_idx); // end of colour depth loop (8) } // vlineDMA() - /** * @brief - update DMA buff drawing a rectangular at specified coordinates * this works much faster than multiple consecutive per-pixel calls to updateMatrixDMABuffer() @@ -953,23 +906,29 @@ uint16_t red16, green16, blue16; * @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){ +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) +{ // h-lines are >2 times faster than v-lines // so will use it only for tall rects with h >2w - if (h>2*w){ + if (h > 2 * w) + { // draw using v-lines - do { + do + { --w; - vlineDMA(x+w, y, h, r,g,b); - } while(w); - } else { + vlineDMA(x + w, y, h, r, g, b); + } while (w); + } + else + { // draw using h-lines - do { + do + { --h; - hlineDMA(x, y+h, w, r,g,b); - } while(h); + hlineDMA(x, y + h, w, r, g, b); + } while (h); } } -#endif // NO_FAST_FUNCTIONS +#endif // NO_FAST_FUNCTIONS -- cgit v1.3.1