刘畊宏刘宇珊:bayer, yuv, RGB转换方法

}

##################################################################################

convert.c

##################################################################################

#include
#include
#include
#include
#include
#include
#include "convert.h"

char *g_src_file = NULL;
char *g_dest_file = NULL;
int g_in_width = 352;
int g_in_height = 292;

unsigned int g_src_fmt = V4L2_PIX_FMT_SGBRG8;
//unsigned int g_dest_fmt = V4L2_PIX_FMT_RGB24;
unsigned int g_dest_fmt = V4L2_PIX_FMT_YUV420;


int process_cmdline(int argc, char **argv)
{
    int i;
    char *tmp;

    for (i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-s") == 0) {
            g_src_file = argv[++i];
        }
        else if (strcmp(argv[i], "d") == 0) {
            g_dest_file = strdup(argv[++i]);
        }
        else if (strcmp(argv[i], "-sf") == 0) {
            tmp = argv[++i];
            if (strlen(tmp) == 4) {
                g_src_fmt = v4l2_fourcc(tmp[0], tmp[1], tmp[2], tmp[3]);
            }
        }
        else if (strcmp(argv[i], "-df") == 0) {
            tmp = argv[++i];
            if (strlen(tmp) == 4) {
                g_dest_fmt = v4l2_fourcc(tmp[0], tmp[1], tmp[2], tmp[3]);
            }
        }
        else if (strcmp(argv[i], "iw") == 0) {
            g_in_width = atoi(argv[++i]);
        }
        else if (strcmp(argv[i], "ih") == 0) {
            g_in_height = atoi(argv[++i]);
        }
    }

    if (g_src_file && g_dest_file == NULL) {
        g_dest_file = malloc(256);
        sprintf(g_dest_file, "%s.out", g_src_file);
    }
    if (g_in_width == 0 || g_in_height == 0) {
        
    }
}

int get_file_size(int fd)
{
    int ret;
    struct stat sb;

    ret = fstat(fd, &sb);
    if (ret == -1) {
        return ret;
    }
    
    return sb.st_size;
}

int get_bits_per_pixel(unsigned int fmt)
{
    int ret;

    switch (fmt) {
    case V4L2_PIX_FMT_RGB24:
        ret = 24;
        break;
    case V4L2_PIX_FMT_SBGGR8:
    case V4L2_PIX_FMT_SGBRG8:
    case V4L2_PIX_FMT_SGRBG8:
    case V4L2_PIX_FMT_SRGGB8:
        ret = 8;
        break;
    case V4L2_PIX_FMT_YUV420:
        ret = 12;
        break;
    case V4L2_PIX_FMT_YUYV:
    case V4L2_PIX_FMT_UYVY:
        ret = 16;
        break;
    default:
        ret = -1;
        break;
    }

    return ret;
}


void convert(void *src, void *dest, int width, int height, unsigned int src_fmt, unsigned int dest_fmt)
{
    switch (src_fmt) {
    case V4L2_PIX_FMT_SGBRG8:
        if (dest_fmt == V4L2_PIX_FMT_RGB24) {
            v4lconvert_bayer_to_rgb24(src, dest, width, height, src_fmt);
        }
        else if (dest_fmt == V4L2_PIX_FMT_YUV420) {
            v4lconvert_bayer_to_yuv420(src, dest, width, height, src_fmt, 0);
        }
        break;
    default:
        break;
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    int fd_src = 0;
    int fd_dest = 0;
    int src_size = 0;
    int dest_size = 0;
    int pix_num;
    void *src = NULL;
    void *dest = NULL;

    process_cmdline(argc, argv);
    if (g_src_file == NULL || g_dest_file == NULL) {
        ret = -1;
        goto bailout;
    }

    printf("input file(%s), output file(%s)\n", g_src_file, g_dest_file);

    fd_src = open(g_src_file, O_RDONLY);
    if (fd_src == -1) {
        ret = -2;
        goto bailout;
    }

    fd_dest = open(g_dest_file, O_RDWR | O_CREAT, 0666);
    if (fd_dest == -1) {
        ret = -3;
        goto bailout;
    }

    src_size = get_file_size(fd_src);
    if (src_size == -1) {
        ret = -4;
        goto bailout;
    }

    pix_num = src_size / (get_bits_per_pixel(g_src_fmt)/8) ;
    //dest_size = pix_num * get_bytes_per_pixel(g_dest_fmt);
    ret = get_bits_per_pixel(g_dest_fmt);
    dest_size = pix_num * ret / 8;

    printf("src_size(%d), dest_size(%d)\n", src_size, dest_size);
    src = malloc(src_size);
    dest = malloc(dest_size);
    if (src == NULL || dest == NULL) {
        ret = -5;
        goto bailout;
    }

    ret = read(fd_src, src, src_size);
    if (ret != src_size) {
        ret = -6;
        goto bailout;
    }

    convert(src, dest, g_in_width, g_in_height, g_src_fmt, g_dest_fmt);

    printf("write out file, size=%d\n", dest_size);
    ret = write(fd_dest, dest, dest_size);
    if (ret != dest_size) {
        ret = -1;
        goto bailout;
    }

bailout:
    if (src)
        free(src);
    if (dest)
        free(dest);
    if (fd_src) 
        close(fd_src);
    if (fd_dest)
        close(fd_dest);
    if (g_dest_file)
        free(g_dest_file);

    printf("ret(%d)\n", ret);
    return ret;
}

##################################################################################

covert.h

##################################################################################

#ifndef __LIBV4LCONVERT_PRIV_H
#define __LIBV4LCONVERT_PRIV_H

#define V4L2_PIX_FMT_SRGGB8 v4l2_fourcc('R', 'G', 'G', 'B')

void v4lconvert_bayer_to_rgb24(const unsigned char *bayer,
        unsigned char *bgr, int width, int height, unsigned int pixfmt);

void v4lconvert_bayer_to_bgr24(const unsigned char *bayer,
        unsigned char *bgr, int width, int height, unsigned int pixfmt);

void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
        int width, int height, unsigned int src_pixfmt, int yvu);


#endif /* __LIBV4LCONVERT_PRIV_H */

##################################################################################

Makefile

##################################################################################

CONVERT := convert
CFLAGS := -static

CC = gcc

$(CONVERT): convert.c bayer.c

    $(CC) -o $@ $^ $(CFLAGS)
clean:
    rm -f *.o $(CONVERT)
##################################################################################