Displaying Images

[Qtakruri]

Hello,

I just got started using the Riverdi module that has the BT817 chip and external memory and I am trying to figure out how to display images and other widgets using this library.
I am trying to modify the Arduino example to display my image and came across the part of the code where you display your logo.

I used EVE asset builder to convert a logo in PNG format to RGB565 and then used HxD to export it as a HEX in a CPP file.
I replaced the PIC array in tft_data.c with the HEX array of the image and used the code below to try and display the picture on the screen. and updated the size, width, height and EVE_cmd_loadimage(MEM_PIC1, EVE_OPT_NODL, MyLogo, sizeof(MyLogo)); but kept the memory location the same.

EVE_color_rgb(WHITE);
EVE_cmd_dl(DL_BEGIN | EVE_BITMAPS);
EVE_cmd_setbitmap(MEM_PIC1, EVE_RGB565, 216, 216);
EVE_cmd_dl(VERTEX2F(EVE_HSIZE - 58, 5));
EVE_cmd_dl(DL_END);

I had it displayed over the Logo on the top right corner but I get a blank white square that has a line in it.

I am not sure what I am missing here, what is the right way to display an image on the screen using this library?

[RudolphRiedel]

That is basically correct, although I would not use HxD since the EVE Asset Builder has a BIN2C tool built in.
How do you get your picture into the memory of the BT817 though?
The EVE_cmd_loadimage() line in tft.c is for not converted .jpg or .png files that the EVE chip converts to an internal format by itself.
With the converted data you would just need to write it to the BT817, for example EVE_memWrite_flash_buffer() should do.

But I would advise against this because your image data should have a size of 91kiB and you do not only need to store this
in the controller, you need to transfer it over the SPI.
My logo is compressed after conversion using the "Asset Compressor" in EAB, the "zopfli" library results in smaller files.
Then I converted the binary to an array with the "BIN2C" tool.
The EVE_cmd_inflate() line only sends the compressed data to the EVE chip and the EVE chip unpacks it to the given location.

However, my example needs to work with the FT810 and up but as you are using a BT817, I strongly recommend using ASTC compressed images.
Compress your image to for example "COMPRESSED_RGBA_ASTC_8x8_KHR", put the resulting raw file thru the "ASSET COMPRESSOR" and load that with EVE_cmd_inflate().

Oh, and if you have not done so, you probably need to change the macro for MEM_PIC1 to a different address, could be 0x00000.
Annother thing I have not gotten around is that the array sizes need to be changed in tft_data.h as well.

[Qtakruri]

Hey Rudolph,

I followed the steps you mentioned earlier and I see something but not the image I want. instead, I get a blank box!

Just to make sure, here are the steps i took to display the image:

1. import image and convert it using Image Utilities as "COMPRESSED_RGBA_ASTC_8x8_KHR"

2. Compress the RAW output file using the "Zopfli" library

3. convert the .zopfli file to .C file as hexadecimal notation

4. copy and paste the array in the .C to const uint16_t MyLogo [2375] PROGMEM = {
   0x78, 0xda, .........}

5. update the array size in tft_data.C and tft_data.h and changed MEM_PIC1 to 0x000000

6. call // EVE_cmd_inflate(MEM_PIC1, MyLogo, sizeof(MyLogo));

7. then call the following code :
   EVE_color_rgb(WHITE);
   EVE_cmd_dl(DL_BEGIN | EVE_BITMAPS);
   EVE_cmd_setbitmap(MEM_PIC1, EVE_ARGB1555, 216, 216);
   EVE_cmd_dl(VERTEX2F(EVE_HSIZE - 58, 5));
   EVE_cmd_dl(DL_END);

Any idea what I am missing ?

**note I do not get a binary file after compressing the files in the asset compressor
**

"My logo is compressed after conversion using the "Asset Compressor" in EAB, the "zopfli" library results in smaller files.
Then I converted the binary to an array with the "BIN2C" tool."

**

[RudolphRiedel]

EVE_cmd_setbitmap(MEM_PIC1, EVE_ARGB1555, 216, 216);

The format would be EVE_ASTC_8X8 then, or is this just a copy-paste error?

I am trying to go thru the exact same steps now, fetch an image, converted it to 216x216, converted that to ASTC-8x8.
Now I wonder what there is a .raw file and a .astc file.
And the Asset Compressor of EAB 2.9.0 does neither allow me to select an output folder, nor compress the file - strange.

[RudolphRiedel]

Hmm, now I am using EAB 2.8 and the .zoepfli file that I got from it does not load with EVE_cmd_inflate().
Boah, somehow this is not my time and it is already late.

[Qtakruri]

Changing the second parameter in EVE_cmd_setbitmap(MEM_PIC1, EVE_ARGB1555, 216, 216); to EVE_ASTC_8X8 Fixed the problem. Thank you I don’t know how I missed this lol Yeah Eve asset builder will not change the output location but it compresses it for me. Thanks again !

[RudolphRiedel]

Still not working for me though, maybe I broke something else. :-)

[RudolphRiedel]

And yes, of course I broke something else, the transfer of buffers larger than 3840 bytes to be precise.
Thank you for the opportunity to find and fix that bug, my modified example is displaying a 216x216 kitty picture now. :-)

[RudolphRiedel]

Ok, I went over it again and modified this a little.
First, these are the files from all the following steps, I grabbed an image of a kitten from the internet, cropped it, resized it.
More specifically this one: https://pixabay.com/de/photos/katze-k%C3%A4tzchen-pussy-cat-welpen-1887197/

pic_test.zip

The resulting picture is 215x203 and the odd numbers are on purpose.

After conversion to ASTC 8x8 the image has 216x208 pixels.

Yes, the compression ratio for full color images is poor, almost not worth it.
Other assets like BT81x UTF-8 fonts with ASTC compressed glyphs are highly compressable though, I believe this is for the most part because the glyphs are monochromatic and ASTC is full color plus alpha.

I use byte format to avoid issues with the endianness across the platforms I am using.
Sometimes I use hex, sometimes I use decimal.
And I make it output long lines as the argument for 80 characters per line is to allow printing out the source code.
Yes, printing, on paper, for example during a trial - so hardly anyone will ever benefit from this rule, definately not when using it for a long list of numbers.
So I go for less lines for the data.
While EAB has 80 bytes as default, it actually should be 16 to stay around 80 characters per line, that would result in 669 lines instead of the 35 I chose to use for this example.

I put the array from kitty_215x203_216x208_COMPRESSED_RGBA_ASTC_8x8_KHR.c in tft_data.c of my example code, renamed it to "pic2", because of why not.
const uint8_t pic2[10700] PROGMEM =
{
...
};

And I put a line for this array in tft_data.h:
extern const uint8_t pic2[10700] PROGMEM;

The size needs to be correct in the header file or the next step will not work.

EVE_cmd_inflate(0, pic2, sizeof(pic2));

The sizeof() needs the external declaration with the size to work.

Now what this does with my library is to send the array by SPI to the command co-processor in chuncks of 3840 bytes.
Why 3840? Because this is the highest multiple of 256 that fits in the cmd FIFO of 4092 bytes and flash pages are written
in multiples of 256.
The command co-processor unpacks the data to the given address.

And here is the reason why I still advise to use the compression, even though the compression ratio is hardly worth it.
The data needs to be correct, corrupt data results in a coprocessor fault.
So this verifies the data.

This is exactly what helped me to quickly find the bug I introduced.
If I had transferred the raw data, I would not have been greeted with a black screen, maybe the image would have been displayed partly corrupted or not all, but I would have searched somewhere else initially. :-)

And for the final step, integrate some lines into the display-list:
EVE_color_rgb(WHITE);
EVE_cmd_dl(DL_BEGIN | EVE_BITMAPS);
EVE_cmd_setbitmap(0, EVE_ASTC_8X8, 216, 208);
EVE_cmd_dl(VERTEX2F(100, 100));
EVE_cmd_dl(DL_END);

If you wonder about the first line, just try what happens when you use a different color. :-)

[Qtakruri]

@RudolphRiedel

Hello again,
I have a very interesting case where I am trying to display images from Flash. I did all the steps in EAB and was able to display all of the images individually and made sure the addresses, sizes, and formats were all correct. but as soon as I try to display two or three images from Flash I get a distorted screen (the screen is split into 4 sections different in color e.g. red blue red blue) the tags work and everything but the two images are not showing.

the battery and wifi stuff are displayed correctly but as soon as I add info box 1 or info box 2 or both it starts acting up.
am I missing something here, is there a limit on how much you can read from flash, are there any processes that are getting in the way of the DL ?

here's the function I am calling in TFT_display();

void show_screen3(void)
{

  EVE_start_cmd_burst();
  EVE_cmd_dl_burst(CMD_DLSTART);
  EVE_cmd_dl_burst(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG);
  EVE_cmd_bgcolor(BLACK); // background color
  EVE_cmd_dl(DL_VERTEX_FORMAT);

  // top gradient
  EVE_cmd_gradient(335, 80, BLACK, 335, 90, 0xCF1F2F);

  if (cp && rp )
  {
    EVE_cmd_setbitmap_burst(0x800000 | (446656 / 32), EVE_ASTC_8X8, 96, 72); // green
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(58, 0));

    EVE_cmd_setbitmap_burst(0x800000 | (1661184 / 32), EVE_ASTC_8X8, 56, 48); //wifi 
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(0, 0));
  }
  else
  {
    EVE_cmd_setbitmap_burst(0x800000 | (444928 / 32), EVE_ASTC_8X8, 96, 72);// gray
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(58, 0));

    EVE_cmd_setbitmap_burst( 0x800000 | (154752 / 32), EVE_ASTC_8X8, 56, 72); //battery outline
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));

    EVE_cmd_setbitmap_burst(0x800000 | (1660480 / 32), EVE_ASTC_8X8, 56, 48);//wifi gray
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(0, 0));
  }
  //  battery
  if (battPercent == 0)
  {
   EVE_cmd_setbitmap_burst( 0x800000 | (154752 / 32), EVE_ASTC_8X8, 56, 72); //battery outline
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }
  else if (battCharging == true)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (152704 / 32), EVE_ASTC_8X8, 56, 72); //battery charging
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }
  else if (battPercent >= 0x4C && battPercent <= 0x64)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (151680 / 32), EVE_ASTC_8X8, 56, 72); //battery 4
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }
  else if (battPercent >= 0x33 && battPercent <= 0x4B)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (150656 / 32), EVE_ASTC_8X8, 56, 72); //battery 3
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }
  else if (battPercent >= 0x19 && battPercent <= 0x31)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (149632 / 32), EVE_ASTC_8X8, 56, 72); //battery 2
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }
  else if (battPercent >= 0x00 && battPercent <= 0x18)
  {
    EVE_cmd_setbitmap_burst( 0x800000 | (148608 / 32), EVE_ASTC_8X8, 56, 72); //battery 1 red
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(156, 0));
  }


  if (cp == true)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (346048 / 32), EVE_ASTC_8X8, 128, 72);
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(294, 0));
    EVE_cmd_setbitmap_burst(0x800000 | (151680 / 32), EVE_ASTC_8X8, 56, 72); //battery 4
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(424, 0));

    EVE_cmd_setbitmap_burst(0x800000 | (1661184 / 32), EVE_ASTC_8X8, 56, 48); // wifi green
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(236, 0));
  }
  else if (cp == false)
  {
    EVE_cmd_setbitmap_burst(0x800000 | (343744 / 32), EVE_ASTC_8X8, 128, 72); 
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(294, 0));

    EVE_cmd_setbitmap_burst( 0x800000 | (154752 / 32), EVE_ASTC_8X8, 56, 72); //battery outline
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(424, 0));

    EVE_cmd_setbitmap_burst(0x800000 | (1660480 / 32), EVE_ASTC_8X8, 56, 48); //WIFI gray
    EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
    EVE_cmd_dl_burst(VERTEX2F(236, 0));
  }

  EVE_cmd_dl(COLOR_RGB(255, 255, 255));
  EVE_cmd_dl_burst(TAG(210));
  EVE_cmd_setbitmap_burst(0x800000 | (430976 / 32), EVE_ASTC_8X8, 96, 96); // back
  EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
  EVE_cmd_dl_burst(VERTEX2F(0, 100));
  EVE_cmd_dl_burst(DL_TAG);


  EVE_cmd_dl_burst(TAG(140));
  EVE_cmd_setbitmap_burst(0x800000 | (433280 / 32), EVE_ASTC_8X8, 80, 80); // home
  EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
  EVE_cmd_dl_burst(VERTEX2F(940, 105));
  EVE_cmd_dl_burst(DL_TAG);

************* this is where the problem happens******************
   EVE_cmd_setbitmap_burst(0x800000 | (385664 / 64), EVE_ASTC_8X8, 400, 336); // info box 2 
   EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
   EVE_cmd_dl_burst(VERTEX2F(80, 169));
   EVE_cmd_dl_burst(DL_TAG);



  EVE_cmd_setbitmap_burst(0x800000 | (348352 / 32), EVE_ASTC_8X8, 400, 336); // info box 2 
  EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
  EVE_cmd_dl_burst(VERTEX2F(544, 169));
  EVE_cmd_dl_burst(DL_TAG);


  EVE_cmd_button(909, 517, 70, 70, 27, 0, "");
  EVE_cmd_dl_burst(TAG(190));
  EVE_cmd_setbitmap_burst(0x800000 | (383296 / 32), EVE_ASTC_8X8, 72, 72); 
  EVE_cmd_dl_burst(DL_BEGIN | EVE_BITMAPS);
  EVE_cmd_dl_burst(VERTEX2F(909, 517));
  EVE_cmd_dl_burst(DL_TAG);


  EVE_cmd_dl(COLOR_RGB(207, 31, 47));
  EVE_cmd_dl(DL_BEGIN | EVE_LINES);
  EVE_cmd_dl(VERTEX2F(233, 90));
  EVE_cmd_dl(VERTEX2F(233, 0));
  EVE_cmd_dl(DL_END);
  // second line
  EVE_cmd_dl(COLOR_RGB(207, 31, 47));
  EVE_cmd_dl(DL_BEGIN | EVE_LINES);
  EVE_cmd_dl(VERTEX2F(500, 90));
  EVE_cmd_dl(VERTEX2F(500, 0));
  EVE_cmd_dl(DL_END);
}

[Qtakruri]

for info box 2 i changed the 64 back to 32 and still doesn't work

[RudolphRiedel]

Yeah, the bandwidth of the flash is limited, there is no cache and it just starts to fail when composing of a scanline takes too long.
The best idea is to try to not display anything directly from flash, fill up RAM_G first before even considering using the flash directly.
At least this got a whole lot easier with ASTC compressed images taking less space.

Fonts are a problem though, they easily can grow very large and you can only cache one.

The limit before it fails can be pushed a little, at the cost of reducing the framerate.

Oh yes, just copying from flash to RAM_G is pretty fast as well, so as static storage the flash is still pretty nice compared to storing the data in the microcontroller.

[Qtakruri]

I see, that's unfortunate.

What is the best way to copy from flash to RAM_G ? do they have to be compressed to use EVE_CMD_inflate ? or should I just use CMD_FLASHREAD ?
and where would this be done? in TFT_init () ?

[RudolphRiedel]

Yes, just use EVE_cmd_flashread() to copy the data you already have directly.
There is CMD_INFLATE2, but to benefit from this you would first need to run out of space in the flash and then it takes longer.

Edit: be aware that there are strict alignement requirements for source, dest and number parameters of CMD_FLASHREAD.

If you only have one set of images and these all fit into RAM_G at the same time, then yes, TFT_init() would be the place.