Как создать картинку, для хранения информации в пикселях

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <gd.h>
 
#define BITMAP_CHAR "*"
#define BACK_GROUND_CHAR "_"
#define NEW_LINE "\n"
#define DEPTH_PERCENT 90
 
#define MAX_FILENAME_SIZE 50
#define MAX_BUFFER_SIZE 128
 
 
typedef struct
{
    size_t red;
    size_t green;
    size_t blue;
    size_t alpha;
} Colors_t;
 
 
size_t drawText(const char *);
 
unsigned short checkImageType(const char *);
 
size_t putData(const char *, char *, char *);
 
unsigned short showError(const char *);
 
 
gdImagePtr createImage(const char *, FILE *);
 
size_t imageColorAt(gdImagePtr, int, int);
 
Colors_t imageColorsForIndex(gdImagePtr, size_t);
 
 
int main(void)
{
    //число записанных байт
    size_t bytes = 0;
 
    //имя файла
    char filename[MAX_FILENAME_SIZE];
 
    //выход из программы
    const char *exitcmd = "quit";
 
 
    while(1)
    {
        printf("\nEnter filename or quit to exit..\n");
 
        //читаем имя файла
        fgets(filename, MAX_FILENAME_SIZE, stdin);
        sscanf(filename, "%s", filename);
 
        //если ввели quit - выходим из программы
        if( ! strcmp(filename, exitcmd) )
            break;
 
        //пробуем прочитать и записать
        bytes = drawText(filename);
        printf("%s Записано %ld байт\n",  (bytes ? "Успешно!" : "Ошибка."), bytes) ;
    }
 
    printf("\nGood bye..\n");
    getchar();
 
    return 0;
}
 
 
 
/*
 * функция для записи данных
 * проверяет, является ли имя файла возможным типом
 * 
 * @param char *filename    Имя файла для проверки и открытия
 * 
 * @return size_t bytes     Число записанных байт или 0 в случае ошибки
 */
size_t drawText(const char *filename)
{
 
    FILE *in;
 
    gdImagePtr res; //для ресурса открытого изображения GD
 
    int srcWidth = 0, srcHeight = 0; //ширина и высота исходного изображения
    int dstWidth = 0, dstHeight = 0; //ширина и высота выходного изображения
 
    //переменные для цикла
    int x = 0;
    int y = 0;
 
    size_t color_index; //индекс цвета
    size_t bytes; //число записанных байт
 
    Colors_t color; //структура цвета (reg, green, blue, alpha)
 
    //буфер для записи данных в файл
    char *buffer = (char *) malloc(sizeof(char *) * MAX_BUFFER_SIZE);
 
    //если не получилось выделить память - выводим ошибку и выходим из функции
    if(!buffer)
        return showError("Не удалось выделить память");
 
    //если неверный тип файла - выводим ошибку и выходим из функции
    if(!checkImageType(filename))
        return showError("Неверное имя файла");
 
    //если не удалось открыть файл - выводим ошибку и выходим из функции
    if ( !(in = fopen(filename, "rb")) )
        return showError("Не удалось открыть файл");
 
    //если не получилось создать изображение - выводим ошибку и выходим из функции
    if( !(res = createImage(filename, in)) )
        return showError("Ошибка создания изображения");
 
    //узнаем исходную ширину и высоту изображения
    srcWidth = gdImageSX(res);
    srcHeight = gdImageSY(res);
 
    // Новая ширина изображения
    dstWidth = (int)( srcWidth / (srcHeight / 20) );
    // Новая высота изображения
    dstHeight = 20;
 
    //создаем пустое изображение
    gdImagePtr out = gdImageCreateTrueColor(dstWidth, dstHeight);
 
    //копируем изображение, подгоняя под нужный размер
    gdImageCopyResampled(out, res, 0, 0, 0, 0, dstWidth, dstHeight, srcWidth, srcHeight);
 
    *buffer = '\0';
    // Проходим по всем пикселам изображений
    for(y = 0; y < dstHeight; y++)
    {
        for(x = 0; x < dstWidth; x++)
        {
            //получаем код цвета пиксела                
            color_index = imageColorAt(out, x, y);
            //переводим в RGB формат по коду цвета пиксела
            color = imageColorsForIndex(out, color_index);
            // Выбор между тонами
            buffer = strcat( buffer, (color.blue < 2.55 * DEPTH_PERCENT ? BITMAP_CHAR : BACK_GROUND_CHAR) );
        }
        // Дополняем вывод переводом строки
        buffer = strcat(buffer, NEW_LINE);
    }
 
    //освобождаем память, выделенную под изображения
    gdImageDestroy(out);
    gdImageDestroy(res);
 
    //закрываем файл
    fclose(in);
 
    //пробуем записать данные в файл
    bytes = putData(filename, "txt", buffer);
 
    //освобождаем выделенную память
    free(buffer);
 
    //возвращаем число записанных байт
    return bytes;
}
 
 
/*
 * Функция для записи данных в файл
 * 
 * @param const char *filename  Имя файла для записи
 * @param char *type        Тип файла для записи
 * @param char *data        Данные для записи
 * 
 * @return size_t bytes         Возвращает количество записанных байт или 0 в случае ошибки
 */
size_t putData(const char *filename, char *type, char *data)
{
    //число записанных байт
    size_t bytes = 0;
    //выделяем память под имя файла
    char tmp[ sizeof filename + sizeof type + 1 ];
 
    FILE *out;
 
    //составляем имя файла
    sprintf(tmp, "%s.%s", filename, type);
 
    //пробуем создать файл
    out = fopen(tmp, "wb");
    if(!out)
        return 0;
    //записываем данные
    bytes = fwrite( data, 1, strlen(data), out );
    //закрываем поток
    fclose(out);
    //возвращаем число записанных байт
    return bytes;
}
 
 
/*
 * Функция проверяет тип файла по переданному имени
 * 
 * @param const char *filename  Имя файла для проверки
 * 
 * @return unsigned short       Возвращает 0 в случае ошибки или 1 в случае успеха
 */
unsigned short checkImageType(const char *filename)
{
    //ищем последнее вхождение точки в имени файла
    const char *type = strrchr(filename, '.');
 
    //допустимые типы файлов
    const char *allowedTypes[] = {"jpeg","jpg","png","gif"};
 
    //счетчик
    int i = 0; 
 
    //вычисляем длину массива с допустимыми типами файлов
    int length = (int) sizeof allowedTypes / sizeof allowedTypes[0];
 
    //если в имени файла отсутствует точка - возвращаем ошибку (0)
    if(!type)
        return 0;
 
    type++;
 
    //если тип файла соответствующий - возвращаем 1, иначе возвращаем 0
    for(i = 0; i < length; i++)
        if(!strcmp(type, allowedTypes[i]))
            return 1;
    return 0;
}
 
 
/*
 * Функция создает изображение
 * 
 * @param const char *filename  Имя файла для создания изображения
 * @param FILE *image           Указатель на файл с изображением
 * 
 * @return gdImagePtr           Возвращает ресурс созданного изображения
 *                              или NULL в случае ошибки
 */
gdImagePtr createImage(const char *filename, FILE *image)
{
    //определяем тип файла
    const char *type = strrchr(filename, '.');
 
    if (!type)
        return NULL;
 
    type++;
 
    //проверяем тип файла и создаем соответствующее изображение
    if(!strcmp(type, "jpeg") || !strcmp(type, "jpg"))
        return gdImageCreateFromJpeg(image);
    if(!strcmp(type, "png"))
        return gdImageCreateFromPng(image);
    if( !strcmp(type, "gif"))
        return gdImageCreateFromGif(image);
    return NULL;
}
 
 
/*
 * @param gdImagePtr im Ресурс с изображением
 * @param int x         Отступ по оси Ox
 * @param int y         Отступ по оси Oy
 * 
 * @return size_t       Возвращает код цвета пиксела или 0 в случае ошибки
 */
size_t imageColorAt(gdImagePtr im, int x, int y)
{
    //если изображение полноцветовое
    if(im->tpixels && gdImageBoundsSafe(im, x, y))
    {
        //если изображение полноцветовое
        if(gdImageTrueColor(im))
            return gdImageTrueColorPixel(im, x, y);
        else
            return im->pixels[y][x];
    }
    return 0;
}
 
 
/*
 * Функция переводит в формат RGB цвет пиксела по коду пиксела
 * 
 * @param gdImagePtr im Ресурс созданного изображения
 * @param size_t col    Код цвета пиксела
 * 
 * @return Colors_t     Возвращает структуру с цветами в RGB
 */
Colors_t imageColorsForIndex(gdImagePtr im, size_t col)
{
    //структура для цвета в формате RGBA
    Colors_t color;
 
    //берем цвета в формате RGBA
    color.red       = gdImageRed(im, col);
    color.green     = gdImageGreen(im, col);
    color.blue      = gdImageBlue(im, col);
    color.alpha     = gdImageAlpha(im, col);
 
    return color;
}
 
 
/*
 * Функция выводит сообщение об ошибке
 * 
 * @param const char *msg   Текст сообщения об ошибке
 * 
 * @return unsigned short   Возвращает 0
 */
unsigned short showError(const char *msg)
{
    printf("\n%s\n", msg);
    return 0;
}