Dit

#include <memory>
#include "render.h"

class DitherProcessor
{
public:
	static DitherProcessor& Instance();
	int ReadImage(const char* input_file);
	int SaveCurrentImage(const char* output_file);
	void Process(int picture_mode, int brightness, int constrast, int gamma, int color);
	uint8_t* GetCurrentImage(size_t* length);

private:
	DitherProcessor();
	int TestSaveCurrentBmpData();
	int width = 0;
	int height = 0;
	size_t bmp_data_len = 0;
	std::unique_ptr<uint8_t[]> source_image = nullptr;
	std::unique_ptr<uint8_t[]> current_image = nullptr;
	std::unique_ptr<uint8_t[]> current_bmp_data = nullptr;
};

#define _CRT_SECURE_NO_WARNINGS
#include "DitherProcessor.h"
#include "bmpView_JY.h"

DitherProcessor& DitherProcessor::Instance()
{
    static DitherProcessor instance;
    return instance;
}

int DitherProcessor::ReadImage(const char* input_file)
{
    uint8_t* src = 0;
	int ret = readBMP_JY(&src, &width, &height, input_file, BGR, true);
    if (ret == BMPVIEW_SUCESS) {
        source_image.reset(src);
        current_image = std::make_unique<uint8_t[]>(width * height * 3);
    }
    return ret;
}

int DitherProcessor::SaveCurrentImage(const char* output_file)
{
	int ret = saveBMP_JY(current_image.get(), width, height, output_file, BGR, true);
    return BMPVIEW_SUCESS;
}

void DitherProcessor::Process(int picture_mode, int brightness, int constrast, int gamma, int color)
{
    ePaperPictureSettings set;
    set.picture_mode = PMODE_CUSTOM;
    set.brightness = 0;
    set.contrast = 100;
    set.gamma = 0;
    set.color = 25;
    uint8_t* dst = process_dither_total(source_image.get(), width, height, set);
    current_image.reset(dst);
}

uint8_t* DitherProcessor::GetCurrentImage(size_t* length)
{
    uint8_t* bmpData = createBmpData(current_image.get(), width, height, &bmp_data_len);
    current_bmp_data.reset(bmpData);
    *length = bmp_data_len;
    return current_bmp_data.get();
}

DitherProcessor::DitherProcessor()
{
}

int DitherProcessor::TestSaveCurrentBmpData()
{
	FILE* fp_t = NULL;
	// if (fopen_s(&fp_t, file_name, "wb") != 0)
	const char* file_name = "output2.bmp";
	fp_t = fopen(file_name, "wb");
	if (fp_t == NULL)
	{
		printf("Error opening file!\n");
		return BMPVIEW_FAILED_OPEN_FILE;
	}

	// write image
	fwrite(current_bmp_data.get(), bmp_data_len, 1, fp_t);
	fclose(fp_t);
	return BMPVIEW_SUCESS;
}

uint8_t* createBmpData(uint8_t* srcImage, int width, int height, size_t* size);

uint8_t* createBmpData(uint8_t* srcImage, int width, int height, size_t* size)
{
	// Bitmap Init
	BMP bmp = new_BMP();
	BMP_init(&bmp, width, height);

	// Stream to bmp
	Stream_to_BMP(&bmp, srcImage, BGR);
	
	// Flipped
	bool isFlipped = true;
	if (isFlipped)
	{
		img_flipped_JY(bmp.data, bmp.infoHeader.biWidth, bmp.infoHeader.biHeight, 3);
	}

	size_t buflen = (54 + width * height * 3) * sizeof(uint8_t);
	uint8_t* buf = (uint8_t*)malloc(buflen);
	if (buf == 0) {
		return nullptr;
		*size = 0;
	}
	*size = buflen;
	memset(buf, 0, buflen);
	uint8_t* cur = buf;
	memcpy(cur, &bmp.fileHeader.bfType, sizeof(bmp.fileHeader.bfType));
	cur += sizeof(bmp.fileHeader.bfType);
	memcpy(cur, &bmp.fileHeader.bfSize, sizeof(bmp.fileHeader.bfSize));
	cur += sizeof(bmp.fileHeader.bfSize);
	memcpy(cur, &bmp.fileHeader.bfReserved1, sizeof(bmp.fileHeader.bfReserved1));
	cur += sizeof(bmp.fileHeader.bfReserved1);
	memcpy(cur, &bmp.fileHeader.bfReserved2, sizeof(bmp.fileHeader.bfReserved2));
	cur += sizeof(bmp.fileHeader.bfReserved2);
	memcpy(cur, &bmp.fileHeader.bfOffBits, sizeof(bmp.fileHeader.bfOffBits));
	cur += sizeof(bmp.fileHeader.bfOffBits);

	memcpy(cur, &bmp.infoHeader.biSize, sizeof(bmp.infoHeader.biSize));
	cur += sizeof(bmp.infoHeader.biSize);
	memcpy(cur, &bmp.infoHeader.biWidth, sizeof(bmp.infoHeader.biWidth));
	cur += sizeof(bmp.infoHeader.biWidth);
	memcpy(cur, &bmp.infoHeader.biHeight, sizeof(bmp.infoHeader.biHeight));
	cur += sizeof(bmp.infoHeader.biHeight);
	memcpy(cur, &bmp.infoHeader.biPlanes, sizeof(bmp.infoHeader.biPlanes));
	cur += sizeof(bmp.infoHeader.biPlanes);
	memcpy(cur, &bmp.infoHeader.biBitCount, sizeof(bmp.infoHeader.biBitCount));
	cur += sizeof(bmp.infoHeader.biBitCount);
	memcpy(cur, &bmp.infoHeader.biCompression, sizeof(bmp.infoHeader.biCompression));
	cur += sizeof(bmp.infoHeader.biCompression);
	memcpy(cur, &bmp.infoHeader.biSizeImage, sizeof(bmp.infoHeader.biSizeImage));
	cur += sizeof(bmp.infoHeader.biSizeImage);
	memcpy(cur, &bmp.infoHeader.biXPelsPerMeter, sizeof(bmp.infoHeader.biXPelsPerMeter));
	cur += sizeof(bmp.infoHeader.biXPelsPerMeter);
	memcpy(cur, &bmp.infoHeader.biYPelsPerMeter, sizeof(bmp.infoHeader.biYPelsPerMeter));
	cur += sizeof(bmp.infoHeader.biYPelsPerMeter);
	memcpy(cur, &bmp.infoHeader.biClrUsed, sizeof(bmp.infoHeader.biClrUsed));
	cur += sizeof(bmp.infoHeader.biClrUsed);
	memcpy(cur, &bmp.infoHeader.biClrImportant, sizeof(bmp.infoHeader.biClrImportant));
	cur += sizeof(bmp.infoHeader.biClrImportant);
	memcpy(cur, bmp.data, sizeof(uint8_t) * bmp.infoHeader.biSizeImage);

	free(bmp.colorPalette);
	free(bmp.data);
	return buf;
}