Как преобразовать поток байтов JPEG в изображение JPEG и отобразить его на 1,8-дюймовом TFT-экране

Вот что я нашел для отображения файлов изображений JPEG на любом TFT -

Я использовал библиотеку JPEGDecoder и вместо tft.pushColor я использовал метод tft.drawPixel.

  for (int jj  =mcu_y;jj<mcu_y + win_h;jj++)
     {
        for (int ii=mcu_x;ii<mcu_x + win_w ;ii++)
        {
            // TFTscreen.drawPixel(ii,jj,tft.color565(255,0,0));
             TFTscreen.drawPixel(ii,jj,*pImg++ ); 
        }
     } 

Для BMP нам нужны значения RGB для рендеринга каждого пикселя на TFT-экране.

Но в случае JPG сначала нам нужно декодировать и создать плитки MCU на TFT. Затем мы раскрашиваем эти тайлы MCU по цвету, который получаем от декодера потока JPEG. Здесь *pImg — это указатель, содержащий информацию о цвете. По мере увеличения массива *pImg++ каждый раз мы получаем новый цветовой код типа uInt8_t. Внутри тайлов MCU эти цвета должны быть введены. Каждая плитка MCU раскрашивается и рисуется в заданной последовательности с учетом того, где находится граница TFT-экрана.

Он автоматически создает изображение JPEG.

///////////////////////////////////////////// //////////////////
#include <Adafruit_GFX.h>    // Базовая графическая библиотека
#include <Adafruit_ST7735.h> // Аппаратная библиотека
#include <Adafruit_ImageReader.h> // Функции чтения изображений

// Для пробоя можно использовать любые 2 или 3 контакта
// Эти контакты также подойдут для экрана TFT 1,8 дюйма.
#define TFT_CS 16
#define TFT_RST 9  // вы также можете подключить это к сбросу Arduino
                      // установите это любые контакты, которые вам нравятся!
// в этом случае установите для этого вывода #define значение -1!
#define TFT_DC 17

// Вариант 2: используйте любые пины, но чуть медленнее!
#define TFT_SCLK 5   // установите любые контакты, которые вам нравятся!
#define TFT_MOSI 23   

Adafruit_ST7735 TFTscreen = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

/////////////////////////////////////////////////// ////////////

#include <JPEGDecoder.h>  // библиотека декодера JPEG

/////////////////////////////////////////////////// ////////////
// подключаем необходимые библиотеки
#include <SPI.h>
#include <SD.h>
/////////////////////////////////////////////////// ////////////


// определение контакта для Mega
#define sd_cs  53
#define lcd_cs 49
#define dc     48
#define rst    47

#define TFT_WHITE 0xFFFF
#define TFT_BLACK 0x0000
#define TFT_RED   0xF800


 /////////////////////////////////////////////////// ////////////

 #define PIN_NUM_MISO 2
#define PIN_NUM_MOSI 15
#define PIN_NUM_CLK  14
#define PIN_NUM_CS   13



  Adafruit_ImageReader reader;
    /////////////////////////////////////////////////// /////





String text="";

// эта функция определяет минимум из двух чисел
#define minimum(a,b)     (((a) < (b)) ? (a) : (b))



  //============================================== ===================================
    // настраивать
    //============================================== ===================================

void setup() {
  // инициализируем GLCD и показываем сообщение
  // просим пользователя открыть последовательную линию
  /////////////////////////////////////////////////// ////////////////
   // Используйте этот инициализатор, если вы используете 1,8-дюймовый TFT-дисплей
  TFTscreen.initR(INITR_BLACKTAB);   // инициализируем чип ST7735S, черная вкладка
/////////////////////////////////////////////////// ////////////////

  TFTscreen.fillScreen(TFT_WHITE); // Альтернатива:

TFTscreen.background(255, 255, 255);



TFTscreen.setTextColor(TFT_RED); // Альтернатива: TFTscreen.stroke(0, 0, 255);
  TFTscreen.println();
  TFTscreen.println(F("Arduino TFT Jpeg Example"));

  TFTscreen.setTextColor(TFT_BLACK); // Альтернатива: TFTscreen.stroke(0, 0, 0);
  TFTscreen.println(F("Open serial monitor"));
  TFTscreen.println(F("to run the sketch"));

  // инициализируем последовательный порт: он будет использоваться для
  // распечатываем некоторую диагностическую информацию
  Serial.begin(115200);
  while (!Serial) {
    // ждем подключения последовательного порта. Требуется только для собственного порта USB
  }

  // очищаем экран GLCD перед запуском
// TFTscreen.background(255, 255, 255);
  TFTscreen.fillScreen(TFT_WHITE);

  // попытаемся получить доступ к SD-карте. Если это не помогло (например,
  // карта отсутствует), процесс установки остановится.
  Serial.print(F("Initializing SD card..."));

/////////////////////////////////////////////////// ////////////////


  SPI.begin(PIN_NUM_CLK, PIN_NUM_MISO, PIN_NUM_MOSI, PIN_NUM_CS);

  if (!SD.begin(PIN_NUM_CS)) {
    Serial.println(F("failed!"));
    while (1); // Инициализация SD не удалась, поэтому подождите здесь
  }
  Serial.println(F("OK!"));
/////////////////////////////////////////////////// ////////////////


  // инициализируем и очищаем экран GLCD
 // TFTscreen.begin();
  TFTscreen.fillScreen(TFT_WHITE); // Альтернатива: TFTscreen.background(255, 255, 255);

  // теперь, когда SD-карта доступна, проверяем
  // файл изображения существует.
  if (SD.exists("/EagleEye.jpg")) {
    Serial.println("EagleEye.jpg found on SD card.");
  } else {
    Serial.println("EagleEye.jpg not found on SD card.");
    while (1); // Файл изображения отсутствует, поэтому оставайтесь здесь
  }

}

//============================================== ===================================
// Основной цикл
//============================================== ===================================
void loop() {

  // открываем файл изображения
  File jpgFile = SD.open( "/EagleEye.jpg", FILE_READ);

  // инициализируем декодер, чтобы предоставить доступ к информации об изображении
  JpegDec.decodeSdFile(jpgFile);

  //выводим информацию об изображении в последовательный порт
  jpegInfo();

  // отображаем изображение на экране по координате 0,0
  renderJPEG(0, 0);

  // подождем немного, прежде чем очистить экран до случайного цвета и снова нарисовать
  delay(4000);

  // очисти экран
  TFTscreen.fillScreen(random(0xFFFF));  // Альтернатива: TFTscreen.background(255, 255, 255);
}

//============================================== ===================================
// Выводим информацию об изображении
//============================================== ===================================

void jpegInfo() {
  Serial.println(F("==============="));
  Serial.println(F("JPEG image info"));
  Serial.println(F("==============="));
  Serial.print(F(  "Width      :")); Serial.println(JpegDec.width);
  Serial.print(F(  "Height     :")); Serial.println(JpegDec.height);
  Serial.print(F(  "Components :")); Serial.println(JpegDec.comps);
  Serial.print(F(  "MCU / row  :")); Serial.println(JpegDec.MCUSPerRow);
  Serial.print(F(  "MCU / col  :")); Serial.println(JpegDec.MCUSPerCol);
  Serial.print(F(  "Scan type  :")); Serial.println(JpegDec.scanType);
  Serial.print(F(  "MCU width  :")); Serial.println(JpegDec.MCUWidth);
  Serial.print(F(  "MCU height :")); Serial.println(JpegDec.MCUHeight);
  Serial.println(F("==============="));
}

//============================================== ===================================
// Декодируем и рисуем на TFT-экране
//============================================== ===================================
void renderJPEG(int xpos, int ypos) {

  // получаем информацию об изображении
  uint16_t *pImg;
  uint16_t mcu_w = JpegDec.MCUWidth;
  uint16_t mcu_h = JpegDec.MCUHeight;
  uint32_t max_x = JpegDec.width;
  uint32_t max_y = JpegDec.height;

  // Изображения Jpeg рисуются как набор блоков изображений (тайлов), называемых минимальными единицами кодирования (MCU).
  // Обычно эти MCU представляют собой блоки размером 16x16 пикселей.
  // Определяем ширину и высоту правого и нижнего краевых блоков изображения
  uint32_t min_w = minimum(mcu_w, max_x % mcu_w);
  uint32_t min_h = minimum(mcu_h, max_y % mcu_h);

  // сохраняем текущий размер блока изображения
  uint32_t win_w = mcu_w;
  uint32_t win_h = mcu_h;

  // записываем текущее время, чтобы мы могли измерить, сколько времени потребуется для рисования изображения
  uint32_t drawTime = millis();

  // сохраняем координаты правого и нижнего краев, чтобы облегчить обрезку изображения
  // к размеру экрана
  max_x += xpos;
  max_y += ypos;

   char str[100];
  // читаем каждый блок MCU, пока их не останется
  while ( JpegDec.read()) {

    // сохраняем указатель на блок изображения
    pImg = JpegDec.pImage;

    // вычисляем, где на экране должен быть нарисован блок изображения
    int mcu_x = JpegDec.MCUx * mcu_w + xpos;
    int mcu_y = JpegDec.MCUy * mcu_h + ypos;

    // проверяем, нужно ли менять размер блока изображения для правого и нижнего края
    if (mcu_x + mcu_w <= max_x) win_w = mcu_w;
    else win_w = min_w;
    if (mcu_y + mcu_h <= max_y) win_h = mcu_h;
    else win_h = min_h;

    // вычисляем, сколько пикселей необходимо отрисовать
    uint32_t mcu_pixels = win_w * win_h;

    // рисуем блок изображения, если он помещается на экране
    if ( ( mcu_x + win_w) <= TFTscreen.width() && ( mcu_y + win_h) <= TFTscreen.height()) {
      // открываем окно на экран, чтобы раскрасить пиксели
      //TFTscreen.setAddrWindow(mcu_x, mcu_y, mcu_x + win_w - 1, mcu_y + win_h - 1);
      //TFTscreen.setAddrWindow(mcu_x, mcu_y, mcu_x + win_w - 1, mcu_y + win_h - 1);
      // выводим все пиксели блока изображения на экран


 /////////////////////////////////////////////////// //////

 // пока (mcu_pixels--)
 // {
 // TFTscreen.pushColor(*pImg++);
 // } // Отправка в TFT по 16 бит за раз



 /////////////////////////////////////////////////// //////



 // Записываем все пиксели MCU в окно TFT





  for (int jj=mcu_y;jj<mcu_y + win_h;jj++)
     {
        for (int ii=mcu_x;ii<mcu_x + win_w ;ii++)
        {
            // TFTscreen.drawPixel(ii,jj,tft.color565(255,0,0));
             TFTscreen.drawPixel(ii,jj,*pImg++ ); 
        }
     } 


 /////////////////////////////////////////////////// //////

    }

    // прекращаем рисовать блоки, если достигнут нижний край экрана
    // функция прерывания закроет файл
    else if ( ( mcu_y + win_h) >= TFTscreen.height()) JpegDec.abort();

  }

  // вычисляем, сколько времени ушло на отрисовку изображения
  drawTime = millis() - drawTime; // Вычисляем время, которое потребовалось



 // распечатываем результаты в последовательный порт
  Serial.print  ("Total render time was    : "); Serial.print(drawTime); Serial.println(" ms");
  Serial.println("=====================================");

}