Könnte mir jemand diesen C++ Code in eine class Bibliothek umschreiben

mein Header

#ifndef __MYPNGDEC__

#define __MYPNGDEC__

#include <Arduino.h>

#include "FS.h"

#include "SD.h"

#include "SPI.h"

#include <TFT_eSPI.h>     

#include <pngdec.h>

#define MAX_IMAGE_WIDTH 320 // Adjust for your images

class PngClass {

public:

void InitPngLib(TFT_eSPI tft );

void listDir(fs::FS &fs, const char * dirname, uint8_t levels);

void DrawPng(int x, int y,const String PngName);

private:

TFT_eSPI * _tft;

File pngfile;

PNG _png;

int xpos;

int ypos;

void * pngOpen(const char *filename, int32_t *size);

void    pngClose(void *handle);

int32_t pngRead(PNGFILE *page, uint8_t *buffer, int32_t length);

int32_t pngSeek(PNGFILE *page, int32_t position);

String readFile(fs::FS &fs, const char * path);  

void pngDraw(PNGDRAW *pDraw);

};

#endif

mein C++ File 

#include "MyPngLib.h"

void PngClass::InitPngLib(TFT_eSPI tft )

{

_tft = tft;

 //SPIClass spi = SPIClass(VSPI);

  Serial.println("**********************************************************");  

  Serial.print("MOSI: ");

  Serial.println(MOSI);

  Serial.print("MISO: ");

  Serial.println(MISO);

  Serial.print("SCK: ");

  Serial.println(SCK);

  Serial.print("SS: ");

  Serial.println(SS);  

  Serial.println("**********************************************************");  

 //if (!SD.begin(SS, spi, 80000000)) 

 if (!SD.begin(SS)) 

 {

      Serial.println("initialization failed!");

    }

  Serial.println("initialization done.");

  listDir(SD, "/", 0);

}

void PngClass::listDir(fs::FS &fs, const char * dirname, uint8_t levels) 

{

  Serial.printf("Listing directory: %s\n", dirname);

  File root = fs.open(dirname);

  if (!root) {

    Serial.println("Failed to open directory");

    return;

  }

  if (!root.isDirectory()) {

    Serial.println("Not a directory");

    return;

  }

  File file = root.openNextFile();

  while (file) {

    if (file.isDirectory()) {

      Serial.print("  DIR : ");

      Serial.println(file.name());

      if (levels) {

        listDir(fs, file.path(), levels - 1);

      }

    } else {

      Serial.print("  FILE: ");

      Serial.print(file.name());

      Serial.print("  SIZE: ");

      Serial.println(file.size());

    }

    file = root.openNextFile();

  }

}

void * PngClass::pngOpen(const char *filename, int32_t *size) 

{

  Serial.printf("Attempting to open %s\n", filename);

  File _pngfile = SD.open(filename, "r");

  *size = _pngfile.size();

  return &pngfile;

}

void PngClass::pngClose(void *handle)

 {

  File _pngfile = *((File*)handle);

  if (_pngfile) _pngfile.close();

}

int32_t PngClass::pngRead(PNGFILE *page, uint8_t *buffer, int32_t length) 

{

  if (!pngfile) return 0;

  page = page; // Avoid warning

  return pngfile.read(buffer, length);

}

int32_t PngClass::pngSeek(PNGFILE *page, int32_t position)

 {

  if (!pngfile) return 0;

  page = page; // Avoid warning

  return pngfile.seek(position);

}

//=========================================v==========================================

//                                      _pngDraw

//====================================================================================

// This next function will be called during decoding of the _png file to

// render each image line to the _tft.  If you use a different _tft library

// you will need to adapt this function to suit.

// Callback function to draw pixels to the display

void PngClass::pngDraw(PNGDRAW *pDraw)

 {

  uint16_t lineBuffer[MAX_IMAGE_WIDTH];

  static uint16_t dmaBuffer[MAX_IMAGE_WIDTH]; // static so buffer persists after fn exit

  _png.getLineAsRGB565(pDraw, lineBuffer, PNG_RGB565_BIG_ENDIAN, 0xffffffff);

  _tft->pushImageDMA(xpos, ypos + pDraw->y, pDraw->iWidth, 1, lineBuffer, dmaBuffer);

}

void PngClass::DrawPng(int x, int y,const String PngName)

{

      xpos = x;

      ypos = y;

      int16_t rc = _png.open(PngName.c_str(), pngOpen, pngClose, pngRead, pngSeek, pngDraw);

      if (rc == PNG_SUCCESS) {

        _tft->startWrite();

        Serial.printf("image specs: (%d x %d), %d bpp, pixel type: %d\n", _png.getWidth(), _png.getHeight(), _png.getBpp(), _png.getPixelType());

        uint32_t dt = millis();

        if (_png.getWidth() > MAX_IMAGE_WIDTH) {

          Serial.println("Image too wide for allocated lin buffer!");

        }

        else {

          rc = _png.decode(NULL, 0);

          _png.close();

        }

        _tft->endWrite();

        // How long did rendering take...

        Serial.print(millis()-dt); Serial.println("ms");

      }

    }

String PngClass::readFile(fs::FS &fs, const char * path)

{

  Serial.printf("Reading file: %s\r\n", path);

  File file = fs.open(path, "r");

  if(!file || file.isDirectory()){

    Serial.println("- empty file or failed to open file");

    return String();

  }

  Serial.println("- read from file:");

  String fileContent;

  while(file.available()){

    fileContent+=String((char)file.read());

  }

  Serial.println(fileContent);

  return fileContent;

}