A way to read from the screen buffer

[twinotter]

I would be adding this to the end of the post asking if there's a way to copy the screen buffer, but that discussion is locked. Probably copying the DMA buffers is the best way if you want an actual copy.

I needed a way to read the pixel back from a buffer (for compositing). The caveat here is that the write operation is lossy - a pixel is luminance adjusted before being written. But this gets you as far as seeing what the actual led values that are being shifted out are:

/** @brief - Read a pixel at specific co-ordinate in the DMA buffer
 */
void IRAM_ATTR MatrixPanel_I2S_DMA::readMatrixDMABuffer(int16_t x_coord, int16_t y_coord, uint8_t *red, uint8_t *green, uint8_t *blue)
{
    if ( !initialized ) { 
      #if SERIAL_DEBUG 
              Serial.println(F("Cannot readMatrixDMABuffer as setup failed!"));
      #endif         
      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 < 0 || y_coord < 0 || x_coord >= PIXELS_PER_ROW || y_coord >= m_cfg.mx_height) {
    return;
  }


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

    *red = 0;
    *green = 0;
    *blue = 0;

    // 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
    //
    // RAM: I tried doing this with #if preprocessor conditionals... but of course the enum doesn't exist until the program is running. strangely, it doesn't give an error or warning
    if (ESP32_I2S_DMA_MODE == I2S_PARALLEL_WIDTH_16) {
	    x_coord & 1U ? --x_coord : ++x_coord;
    } else if (ESP32_I2S_DMA_MODE == I2S_PARALLEL_WIDTH_8) {
	    x_coord = x_coord & 2U ? x_coord - 2 : x_coord + 2;
    }
    // else // what should the mapping be for 24 bits???

    uint16_t _colorbitclear = BITMASK_RGB1_CLEAR, _colorbitoffset = 0;

    if (y_coord >= ROWS_PER_FRAME){    // if we are drawing to the bottom part of the panel
      _colorbitoffset = BITS_RGB2_OFFSET;
      _colorbitclear  = 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 color_depth_idx = PIXEL_COLOR_DEPTH_BITS;
    do {
        --color_depth_idx;
	//
        // 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
        ESP32_I2S_DMA_STORAGE_TYPE *p = getRowDataPtr(y_coord, color_depth_idx, back_buffer_id);

	*red <<= 1;
	*green <<= 1;
	*blue <<= 1;

	*red |= (p[x_coord] >> (_colorbitoffset + 0)) & 1U;
 	*green |= (p[x_coord] >> (_colorbitoffset + 1)) & 1U;
	*blue |= (p[x_coord] >> (_colorbitoffset + 2)) & 1U;

    } while(color_depth_idx);  // end of color depth loop (8)

#if PIXEL_COLOR_DEPTH_BITS < 8
    *red <<= MASK_OFFSET;
    *green <<= MASK_OFFSET;
    *blue <<= MASK_OFFSET
#endif		

    if (m_cfg.driver == HUB75_I2S_CFG::FM6126A) { // the FM6126A needs blue and green swapped
      uint8_t temp;
      temp = *blue;
      *blue = *green;
      *green = temp;
    }

#if 0 // if you wanted to try to reverse the lumConv you could do it here... it's probably not critical unless you were trying to do a screen scrape
  /* 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 color_depth_idx of 0 to be sent out to the MATRIX unless the 'value' of a color is exactly '1'
   * https://ledshield.wordpress.com/2012/11/13/led-brightness-to-your-eye-gamma-correction-no/
	 */
#ifndef NO_CIE1931
	red   = lumConvTab[red];
	green = lumConvTab[green];
	blue  = lumConvTab[blue]; 	
#endif
#endif

} // readMatrixDMABuffer (specific co-ords change)

[mrcodetastic]

I strong suggest just creating your own screen buffer outside this library, and store the pixel values there if memory isn't an issue.

I take it you're trying to drive a huge resolution and therefore don't have the luxary of your own buffer? Something like (this needs FastLED) works for me and deals with the flicker issue completely, and allows one to read the value back of a pixel coord.

Also negates the need to have 'double buffering' enabled in the library.

struct layerPixels {
	CRGB data[LAYER_HEIGHT][LAYER_WIDTH]; 
};

class Layer : public GFX
{
	public:

		Layer(MatrixPanel_I2S_DMA &disp) : GFX (LAYER_WIDTH, LAYER_HEIGHT) {
			matrix = &disp;
		}

		inline void init()
		{
			// https://stackoverflow.com/questions/5914422/proper-way-to-initialize-c-structs
			pixels = new layerPixels();
			
		} // end Layer

		void drawPixel(int16_t x, int16_t y, uint16_t color);   		// overwrite adafruit implementation
		void drawPixel(int16_t x, int16_t y, int r, int g, int b);		// Layer implementation		
		void drawPixel(int16_t x, int16_t y, CRGB color);				// Layer implementation		
		void clear();
	    void display();  //	flush to display / LED matrix

		inline uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
					return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
		}

		// For layer composition - accessed publically
		layerPixels *pixels;

		// Release Memory
		~Layer(void); 

	private:
		MatrixPanel_I2S_DMA *matrix = NULL;		
};


// For adafruit
void Layer::drawPixel(int16_t x, int16_t y, uint16_t color) {

	// 565 color conversion
	uint8_t r = ((((color >> 11)  & 0x1F) * 527) + 23) >> 6;
	uint8_t g = ((((color >> 5)   & 0x3F) * 259) + 33) >> 6;
	uint8_t b = (((color & 0x1F)  * 527) + 23) >> 6;

	drawPixel(x, y, CRGB(r,g,b));
}

void Layer::drawPixel(int16_t x, int16_t y, int r, int g, int b) {
	drawPixel(x, y, CRGB(r,g,b));
}

void Layer::drawPixel(int16_t x, int16_t y, CRGB color) {

	if( x >= LAYER_WIDTH 	|| x < 0) return; // 0;
	if( y >= LAYER_HEIGHT 	|| y < 0) return; // 0;
	
	pixels->data[y][x] = color;
}

void Layer::clear() { 

	memset(pixels, BLACK_BACKGROUND_PIXEL_COLOUR, sizeof(layerPixels) );
}

/**
 * Send the layer to the display device.
 */
void Layer::display() { 

	CRGB _pixel = 0 ;
	for (int y = 0; y < LAYER_HEIGHT; y++) {
		for (int x = 0; x < LAYER_WIDTH; x++)
		{
			//_pixel = pixel[XY(x, y)];
			_pixel = pixels->data[y][x];

			matrix->drawPixelRGB888( x, y, _pixel.r, _pixel.g, _pixel.b);

		} // end loop to copy fast led to the dma matrix
	}

} // display



Layer::~Layer(void)
{
  free(pixels);
}

[twinotter]

This is definitely my next approach to try. :-) I am memory constrained mostly because the TLS wifi drivers are so honking huge. But, parts of the screen are animated, so double buffering is necessary.

One silly idea: use a smaller than screen sized double-buffer. If your secondary layer is just the size of the animated element being changed, then you could get away with transcribing that layer into the display buffer with minimal impact...

[mrcodetastic]

There is a new example which implements an off-screen buffer at the risk of using tonnes of memory:
#225