c语言模块化思想的GEC6818电子相册代码，使用交叉开发原理，使用文件IO接口函数，能够打开文件设备、读写文件设备，来读取BMP图片文件得信息，通过算法实现转换后把数据正确得显示到开发板上去图片显示程序，可以正确打开触摸屏设备文件，捕捉触摸事件的产生并能判断手指滑动的方向来实现图片的切换图片切换程序。

以下是一个示例代码，可以实现你所描述的功能。但是需要注意的是，这个代码仅供参考，可能还需要根据你的具体需求进行修改和优化。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <linux/input.h>

#define MAX_TOUCH_X 800
#define MAX_TOUCH_Y 480

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int DWORD;
typedef int BOOL;

typedef struct tagBITMAPFILEHEADER
{
    WORD bfType;
    DWORD bfSize;
    WORD bfReserved1;
    WORD bfReserved2;
    DWORD bfOffBits;
} BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER
{
    DWORD biSize;
    DWORD biWidth;
    DWORD biHeight;
    WORD biPlanes;
    WORD biBitCount;
    DWORD biCompression;
    DWORD biSizeImage;
    DWORD biXPelsPerMeter;
    DWORD biYPelsPerMeter;
    DWORD biClrUsed;
    DWORD biClrImportant;
} BITMAPINFOHEADER;

typedef struct tagRGBQUAD
{
    BYTE rgbBlue;
    BYTE rgbGreen;
    BYTE rgbRed;
    BYTE rgbReserved;
} RGBQUAD;

typedef struct tagBITMAPINFO
{
    BITMAPINFOHEADER bmiHeader;
    RGBQUAD bmiColors[1];
} BITMAPINFO;

typedef struct tagDISPLAY_IMAGE
{
    int width;
    int height;
    int bpp;
    BYTE *data;
} DISPLAY_IMAGE;

int open_file(char *filename)
{
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        printf("open file %s failed: %s\n", filename, strerror(errno));
        return -1;
    }
    return fd;
}

int read_file(int fd, void *buf, int size)
{
    int nread = read(fd, buf, size);
    if (nread < 0) {
        printf("read file failed: %s\n", strerror(errno));
        return -1;
    }
    return nread;
}

int write_file(int fd, void *buf, int size)
{
    int nwrite = write(fd, buf, size);
    if (nwrite < 0) {
        printf("write file failed: %s\n", strerror(errno));
        return -1;
    }
    return nwrite;
}

int close_file(int fd)
{
    int ret = close(fd);
    if (ret < 0) {
        printf("close file failed: %s\n", strerror(errno));
        return -1;
    }
    return 0;
}

int read_bmp_header(int fd, BITMAPFILEHEADER *header, BITMAPINFOHEADER *info)
{
    int nread = read_file(fd, header, sizeof(BITMAPFILEHEADER));
    if (nread != sizeof(BITMAPFILEHEADER)) {
        printf("read bmp header failed: %s\n", strerror(errno));
        return -1;
    }

    if (header->bfType != 0x4d42) {
        printf("invalid bmp file\n");
        return -1;
    }

    nread = read_file(fd, info, sizeof(BITMAPINFOHEADER));
    if (nread != sizeof(BITMAPINFOHEADER)) {
        printf("read bmp info header failed: %s\n", strerror(errno));
        return -1;
    }

    if (info->biBitCount != 24) {
        printf("unsupported bmp format, only support 24bpp\n");
        return -1;
    }

    return 0;
}

int read_bmp_data(int fd, DISPLAY_IMAGE *image)
{
    int i, j, k;
    BYTE buffer[4];

    image->width = 0;
    image->height = 0;
    image->bpp = 0;
    image->data = NULL;

    BITMAPFILEHEADER header;
    BITMAPINFOHEADER info;

    if (read_bmp_header(fd, &header, &info) < 0) {
        return -1;
    }

    image->width = info.biWidth;
    image->height = info.biHeight;
    image->bpp = info.biBitCount / 8;
    if (image->bpp <= 0 || image->bpp > 4) {
        printf("unsupported bpp: %d\n", image->bpp);
        return -1;
    }

    image->data = (BYTE *)malloc(image->width * image->height * image->bpp);
    if (image->data == NULL) {
        printf("malloc failed\n");
        return -1;
    }

    int line_size = ((image->width * image->bpp + 3) / 4) * 4;
    for (i = 0; i < image->height; i++) {
        for (j = 0; j < image->width; j++) {
            for (k = 0; k < image->bpp; k++) {
                if (read_file(fd, &buffer[k], 1) != 1) {
                    printf("read bmp data failed: %s\n", strerror(errno));
                    return -1;
                }
            }
            memcpy(&image->data[(image->height - i - 1) * image->width * image->bpp + j * image->bpp], buffer, image->bpp);
        }
        if (line_size > image->width * image->bpp) {
            if (read_file(fd, buffer, line_size - image->width * image->bpp) != line_size - image->width * image->bpp) {
                printf("read bmp data failed: %s\n", strerror(errno));
                return -1;
            }
        }
    }

    return 0;
}

int init_display(int *fbfd, struct fb_var_screeninfo *vinfo, struct fb_fix_screeninfo *finfo, BYTE **fbp)
{
    *fbfd = open("/dev/fb0", O_RDWR);
    if (*fbfd == -1) {
        printf("Error: cannot open framebuffer device.\n");
        return -1;
    }

    if (ioctl(*fbfd, FBIOGET_FSCREENINFO, finfo) == -1) {
        printf("Error: reading fixed information.\n");
        close(*fbfd);
        return -1;
    }

    if (ioctl(*fbfd, FBIOGET_VSCREENINFO, vinfo) == -1) {
        printf("Error: reading variable information.\n");
        close(*fbfd);
        return -1;
    }

    // map framebuffer to user memory
    *fbp = (BYTE *)mmap(0, finfo->smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, *fbfd, 0);
    if (*fbp == MAP_FAILED) {
        printf("Error: failed to map framebuffer memory.\n");
        close(*fbfd);
        return -1;
    }

    return 0;
}

int display_image(BYTE *fbp, int x, int y, DISPLAY_IMAGE *image)
{
    int i, j;
    BYTE *p = fbp + y * 800 * 4 + x * 4;

    for (i = 0; i < image->height; i++) {
        for (j = 0; j < image->width; j++) {
            BYTE *q = &image->data[i * image->width * image->bpp + j * image->bpp];
            if (image->bpp == 3) {
                p[0] = q[2];
                p[1] = q[1];
                p[2] = q[0];
                p[3] = 0;
            } else if (image->bpp == 4) {
                p[0] = q[2];
                p[1] = q[1];
                p[2] = q[0];
                p[3] = q[3];
            }
            p += 4;
        }
    }

    return 0;
}

int close_display(BYTE *fbp, int fbfd)
{
    munmap(fbp, 800 * 480 * 4);
    close(fbfd);
    return 0;
}

int open_touch_screen(int *tsfd)
{
    *tsfd = open("/dev/input/event0", O_RDONLY);
    if (*tsfd == -1) {
        printf("Error: cannot open touch screen device.\n");
        return -1;
    }
    return 0;
}

int read_touch_screen(int tsfd, struct input_event *event)
{
    int nread = read(tsfd, event, sizeof(struct input_event));
    if (nread != sizeof(struct input_event)) {
        printf("read touch screen failed: %s\n", strerror(errno));
        return -1;
    }
    return 0;
}

int close_touch_screen(int tsfd)
{
    close(tsfd);
    return 0;
}

int get_touch_direction(struct input_event *current, struct input_event *previous)
{
    int dx = current->value - previous->value;
    if (dx > 0) {
        return 1;
    } else if (dx < 0) {
        return -1;
    }
    return 0;
}

int main()
{
    int fbfd, tsfd;
    struct fb_var_screeninfo vinfo;
    struct fb_fix_screeninfo finfo;
    BYTE *fbp;

    if (init_display(&fbfd, &vinfo, &finfo, &fbp) < 0) {
        return -1;
    }

    if (open_touch_screen(&tsfd) < 0) {
        close_display(fbp, fbfd);
        return -1;
    }

    int fd = open_file("image.bmp");
    if (fd < 0) {
        close_touch_screen(tsfd);
        close_display(fbp, fbfd);
        return -1;
    }

    DISPLAY_IMAGE image;
    if (read_bmp_data(fd, &image) < 0) {
        close_file(fd);
        close_touch_screen(tsfd);
        close_display(fbp, fbfd);
        return -1;
    }

    display_image(fbp, 0, 0, &image);

    struct input_event current, previous;
    memset(&previous, 0, sizeof(previous));
    while (true) {
        if (read_touch_screen(tsfd, &current) <