RGB2UYVY 图像格式转换代码，使用乘法查表，没有使用汇编优化

前阵系统要编译到64位系统环境下，不会64位汇编。只好把代码里涉及到汇编的图像格式转换改成纯运算的方法。

因为是浮点运算，速度很慢。后来抽时间换成乘法查表的方式，计算速度没有像预期那样飙升，因为是用的工作站，或许是因为CPU本身浮点运算够强，不过多少有点益处。

如果换成加法也查表，那就大概需要16MB的空间，把加法运算也加进来查表应该不会提升太多，就没考虑了。

写法上用的C方式，借鉴类似C++的对象结构

#ifndef _RGB_UYVY_INCLUDE_H_  
#define _RGB_UYVY_INCLUDE_H_  
 
typedef struct 
{  
    FLOAT r_table[256];  
    FLOAT g_table[256];  
    FLOAT b_table[256];  
}rgb2yuv_table_t;  
 
static rgb2yuv_table_t* create_rgb_y_table()  
{  
    rgb2yuv_table_t* p_table;  
    INT i;  
 
    p_table = (rgb2yuv_table_t*)malloc(sizeof(rgb2yuv_table_t));  
    if (!p_table)  
        return NULL;  
 
    for (i = 0; i <= 255; i++)  
    {  
        p_table->r_table[i] = 0.299f*i;  
        p_table->g_table[i] = 0.587f*i;  
        p_table->b_table[i] = 0.114f*i;  
    }  
 
    return p_table;  
}  
 
static rgb2yuv_table_t* create_rgb_u_table()  
{  
    rgb2yuv_table_t* p_table;  
    INT i;  
 
    p_table = (rgb2yuv_table_t*)malloc(sizeof(rgb2yuv_table_t));  
    if (!p_table)  
        return NULL;  
 
    for (i = 0; i <= 255; i++)  
    {  
        p_table->r_table[i] = (-0.169f)*i;  
        p_table->g_table[i] = (-0.331f)*i;  
        p_table->b_table[i] = 0.5f*i + 128;  
    }  
 
    return p_table;  
}  
 
static rgb2yuv_table_t* create_rgb_v_table()  
{  
    rgb2yuv_table_t* p_table;  
    INT i;  
 
    p_table = (rgb2yuv_table_t*)malloc(sizeof(rgb2yuv_table_t));  
    if (!p_table)  
        return NULL;  
 
    for (i = 0; i <= 255; i++)  
    {  
        p_table->r_table[i] = 0.5f*i;  
        p_table->g_table[i] = (-0.419f)*i;  
        p_table->b_table[i] = (-0.082f)*i + 128;  
    }  
 
    return p_table;  
}  
 
typedef struct   
{  
    INT i_width;  
    INT i_height;  
 
    INT i_rgb_pixel_byte;  
 
    rgb2yuv_table_t* p_y_table;  
    rgb2yuv_table_t* p_u_table;  
    rgb2yuv_table_t* p_v_table;  
 
} rgb_yuv_sys_t;  
 
static void release_rgb_uyvy(HANDLE handle)  
{  
    rgb_yuv_sys_t* p_sys = (rgb_yuv_sys_t*)handle;  
 
    if (!p_sys)  
        return;  
 
    if (p_sys->p_y_table)  
        free(p_sys->p_y_table);  
 
    if (p_sys->p_u_table)  
        free(p_sys->p_u_table);  
 
    if (p_sys->p_v_table)  
        free(p_sys->p_v_table);  
 
    free(p_sys);  
}  
 
static HANDLE create_rgb_uyvy(INT i_width, INT i_height, INT i_rgb_pixel_bits)  
{  
    rgb_yuv_sys_t* p_sys = (rgb_yuv_sys_t*)malloc(sizeof(rgb_yuv_sys_t));  
    if (!p_sys)  
        return NULL;  
 
    ZeroMemory(p_sys, sizeof(rgb_yuv_sys_t));  
 
    p_sys->i_width = i_width;  
    p_sys->i_height = i_height;  
    p_sys->i_rgb_pixel_byte = i_rgb_pixel_bits / 8;  
 
    p_sys->p_y_table = create_rgb_y_table();  
    if (!p_sys->p_y_table)  
    {  
        release_rgb_uyvy(p_sys);   
        return NULL;  
    }  
 
    p_sys->p_u_table = create_rgb_u_table();  
    if (!p_sys->p_u_table)  
    {  
        release_rgb_uyvy(p_sys);   
        return NULL;  
    }  
 
    p_sys->p_v_table = create_rgb_v_table();  
    if (!p_sys->p_v_table)  
    {  
        release_rgb_uyvy(p_sys);   
        return NULL;  
    }  
 
    return (HANDLE)p_sys;  
}  
 
#define rgb_yuv_pixel(r, g, b, yuv, p_sys)\  
    (yuv) = (BYTE)((p_sys)->r_table[(r)] + (p_sys)->g_table[(g)] + (p_sys)->b_table[(b)])  
 
static void rgb_uyvy(HANDLE handle, BYTE* p_in_r, BYTE* p_in_g, BYTE* p_in_b, BYTE* p_out_uyuv)  
{  
    INT i_line;  
    INT i_pixel;  
 
    rgb_yuv_sys_t* p_table = (rgb_yuv_sys_t*)handle;  
 
    INT i_width = p_table->i_width;  
    INT i_height = p_table->i_height;  
    INT i_rgb_pixel_byte = p_table->i_rgb_pixel_byte;  
 
    rgb2yuv_table_t* p_y_table = p_table->p_y_table;  
    rgb2yuv_table_t* p_u_table = p_table->p_u_table;  
    rgb2yuv_table_t* p_v_table = p_table->p_v_table;  
 
    BYTE* p_y = p_out_uyuv + 1;  
    BYTE* p_u = p_out_uyuv;  
    BYTE* p_v = p_out_uyuv + 2;  
 
    for (i_line = 0; i_line < i_height; i_line++)  
    {  
        for (i_pixel = 0; i_pixel < i_width; i_pixel++)  
        {  
            if ( (i_line+1)%2 )  
            {  
                rgb_yuv_pixel(*p_in_r, *p_in_g, *p_in_b, *p_y, p_y_table);  
                rgb_yuv_pixel(*p_in_r, *p_in_g, *p_in_b, *p_u, p_u_table);  
                rgb_yuv_pixel(*p_in_r, *p_in_g, *p_in_b, *p_v, p_v_table);  
                p_y += 2; p_u += 4; p_v += 4;  
            }  
            else 
            {  
                rgb_yuv_pixel(*p_in_r, *p_in_g, *p_in_b, *p_in_y, p_y_table);     
                p_y += 2;  
            }  
            p_in_r += i_rgb_pixel_byte; p_in_g += i_rgb_pixel_byte; p_in_b += i_rgb_pixel_byte;  
        }  
    }  
}  
 
#endif // _RGB_UYVY_INCLUDE_H_ 

具体使用方法：

HANDLE  h_rgb_uyvy = NULL;  
INT     i_width;  
INT     i_height;  
BYTE*   p_rgb32;  
BYTE*   p_uyvy;  
 
h_rgb_uyvy = create_rgb_uyvy(i_width, i_height, 32);  
if (!h_rgb_uyvy)  
{  
    release_rgb_uyvy(h_rgb_uyvy);  
    return;  
}  
 
rgb_uyvy(h_rgb_uyvy, p_rgb32+2, p_rgb32+1, p_rgb32, p_uyvy);  
....  
 
release_rgb_uyvy(h_rgb_uyvy);  
h_rgb_uyvy = NULL;