RGB24 转换为 YUV12 的算法

头文件:

#ifndef __rgb_2yuv_h__
#define __rgb_2yuv_h__

#ifdef __cplusplus
extern "C" 
{
#endif 

int RGB2YUV (int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip);

#ifdef __cplusplus
}
#endif


#endif

实现文件:

/**************************************************************************
*                                                                        *
* This code is developed by Adam Li.  This software is an                *
* implementation of a part of one or more MPEG-4 Video tools as          *
* specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
* software module in hardware or software products are advised that its  *
* use may infringe existing patents or copyrights, and any such use      *
* would be at such party's own risk.  The original developer of this     *
* software module and his/her company, and subsequent editors and their  *
* companies (including Project Mayo), will have no liability for use of  *
* this software or modifications or derivatives thereof.                 *
*                                                                        *
* Project Mayo gives users of the Codec a license to this software       *
* module or modifications thereof for use in hardware or software        *
* products claiming conformance to the MPEG-4 Video Standard as          *
* described in the Open DivX license.                                    *
*                                                                        *
* The complete Open DivX license can be found at                         *
* http://www.projectmayo.com/opendivx/license.php .                      *
*                                                                        *
**************************************************************************/

/**************************************************************************
*
*  rgb2yuv.c, 24-bit RGB bitmap to YUV converter
*
*  Copyright (C) 2001  Project Mayo
*
*  Adam Li
*
*  DivX Advance Research Center <darc@projectmayo.com>
*
**************************************************************************/

/* This file contains RGB to YUV transformation functions.                */

#include "stdlib.h"
#include "rgb2yuv.h"

static  float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static  float RGBYUV01684[256], RGBYUV03316[256];
static  float RGBYUV04187[256], RGBYUV00813[256];

void InitLookupTable();

/************************************************************************
*
*  int RGB2YUV (int x_dim, int y_dim, void *bmp, YUV *yuv)
*
*    Purpose :    It takes a 24-bit RGB bitmap and convert it into
*                YUV (4:2:0) format
*
*  Input :        x_dim    the x dimension of the bitmap
*                y_dim    the y dimension of the bitmap
*                bmp        pointer to the buffer of the bitmap
*                yuv        pointer to the YUV structure
*
*  Output :    0        OK
*                1        wrong dimension
*                2        memory allocation error
*
*    Side Effect :
*                None
*
*    Date :        09/28/2000
*
*  Contacts:
*
*  Adam Li
*
*  DivX Advance Research Center <darc@projectmayo.com>
*
************************************************************************/

int RGB2YUV ( int x_dim,  int y_dim,  void *bmp,  void *y_out,  void *u_out,  void *v_out,  int flip)
{
    static int init_done = 0;

    long i, j, size;
    unsigned char *r, *g, *b;
    unsigned char *y, *u, *v;
    unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;
    unsigned char *y_buffer, *u_buffer, *v_buffer;
    unsigned char *sub_u_buf, *sub_v_buf;

    if (init_done == 0)
    {
        InitLookupTable();
        init_done = 1;
    }

    // check to see if x_dim and y_dim are divisible by 2
    if ((x_dim % 2) || (y_dim % 2)) return 1;
    size = x_dim * y_dim;

    // allocate memory
    y_buffer = (unsigned char *)y_out;
    sub_u_buf = (unsigned char *)u_out;
    sub_v_buf = (unsigned char *)v_out;
    u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
    v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
    if (!(u_buffer && v_buffer))
    {
        if (u_buffer) free(u_buffer);
        if (v_buffer) free(v_buffer);
        return 2;
    }

    b = (unsigned char *)bmp;
    y = y_buffer;
    u = u_buffer;
    v = v_buffer;

    // convert RGB to YUV
    if (!flip) {
        for (j = 0; j < y_dim; j ++)
        {
            y = y_buffer + (y_dim - j - 1) * x_dim;
            u = u_buffer + (y_dim - j - 1) * x_dim;
            v = v_buffer + (y_dim - j - 1) * x_dim;

            for (i = 0; i < x_dim; i ++) {
                g = b + 1;
                r = b + 2;
                *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
                *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
                *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
                b += 3;
                y ++;
                u ++;
                v ++;
            }
        }
    } else {
        for (i = 0; i < size; i++)
        {
            g = b + 1;
            r = b + 2;
            *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
            *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
            *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
            b += 3;
            y ++;
            u ++;
            v ++;
        }
    }

    // subsample UV
    for (j = 0; j < y_dim/2; j ++)
    {
        psu = sub_u_buf + j * x_dim / 2;
        psv = sub_v_buf + j * x_dim / 2;
        pu1 = u_buffer + 2 * j * x_dim;
        pu2 = u_buffer + (2 * j + 1) * x_dim;
        pv1 = v_buffer + 2 * j * x_dim;
        pv2 = v_buffer + (2 * j + 1) * x_dim;
        for (i = 0; i < x_dim/2; i ++)
        {
            *psu = (*pu1 + *(pu1+1) + *pu2 + *(pu2+1)) / 4;
            *psv = (*pv1 + *(pv1+1) + *pv2 + *(pv2+1)) / 4;
            psu ++;
            psv ++;
            pu1 += 2;
            pu2 += 2;
            pv1 += 2;
            pv2 += 2;
        }
    }

    free(u_buffer);
    free(v_buffer);

    return 0;
}


void InitLookupTable()
{
    int i;

    for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
    for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
    for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
    for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
    for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
    for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
    for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
}

测试程序:

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *        Dave Mackie        dmackie@cisco.com
 */

#include <mpeg4ip.h>
#include <mpeg4ip_getopt.h>
#include "rgb2yuv.h"


/* globals */
char* progName;

/*
 * rgb2yuv
 * required arg1 should be the input RAW RGB24 file
 * required arg2 should be the output RAW YUV12 file
 */ 
static  const  char *usage = 
"\t--flip           - flip image\n"
"\t--height <value> - specify height\n"
"\t--width <value>  - specify width\n"
"\t--version        - display version\n";

int main( int argc,  char** argv)
{
    /* variables controlable from command line */
    u_int frameWidth = 320;            /* --width=<uint> */
    u_int frameHeight = 240;        /* --height=<uint> */
    bool flip = FALSE;                /* --flip */

    /* internal variables */
    char* rgbFileName = NULL;
    char* yuvFileName = NULL;
    FILE* rgbFile = NULL;
    FILE* yuvFile = NULL;
    u_int8_t* rgbBuf = NULL;
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int32_t videoFramesWritten = 0;
    bool gotheight, gotwidth;

    gotheight = gotwidth = FALSE;

    /* begin process command line */
    progName = argv[0];
    while (1) {
        int c = -1;
        int option_index = 0;
        static struct option long_options[] = {
            { "flip", 0, 0, 'f' },
            { "height", 1, 0, 'h' },
            { "width", 1, 0, 'w' },
            { "version", 0, 0, 'V' },
            { NULL, 0, 0, 0 }
        };

        c = getopt_long_only(argc, argv, "fh:w:V",
            long_options, &option_index);

        if (c == -1)
            break;

        switch (c) {
        case 'f': {
            flip = TRUE;
            break;
        }
        case 'h': {
            /* --height <pixels> */
            u_int i;
            gotheight = TRUE;
            if (sscanf(optarg, "%u", &i) < 1) {
                fprintf(stderr, 
                    "%s: bad height specified: %s\n",
                     progName, optarg);
            } else if (i & 1) {
                fprintf(stderr, 
                    "%s: bad height specified, must be multiple of 2: %s\n",
                     progName, optarg);
            } else {
                /* currently no range checking */
                frameHeight = i;
            }
            break;
        }
        case 'w': {
            /* -width <pixels> */
            u_int i;
            gotwidth = TRUE;
            if (sscanf(optarg, "%u", &i) < 1) {
                fprintf(stderr, 
                    "%s: bad width specified: %s\n",
                     progName, optarg);
            } else if (i & 1) {
                fprintf(stderr, 
                    "%s: bad width specified, must be multiple of 2: %s\n",
                     progName, optarg);
            } else {
                /* currently no range checking */
                frameWidth = i;
            }
            break;
        }
        case '?':
          fprintf(stderr, 
              "usage: %s <rgb-file> <yuv-file>\n%s",
              progName, usage);
          return (0);
        case 'V':
          fprintf(stderr, "%s - %s version %s\n",
              progName, MPEG4IP_PACKAGE, MPEG4IP_VERSION);
          return (0);
        default:
            fprintf(stderr, "%s: unknown option specified, ignoring: %c\n", 
                progName, c);
        }
    }

    /* check that we have at least two non-option arguments */
    if ((argc - optind) < 2) {
        fprintf(stderr, 
            "usage: %s <rgb-file> <yuv-file>\n%s",
            progName, usage);
        exit(1);
    }

    if (gotheight == FALSE || gotwidth == FALSE) {
      fprintf(stderr, "%s - you haven't specified height or width - going with %dx%d", 
          progName, frameWidth, frameHeight);
    }
    /* point to the specified file names */
    rgbFileName = argv[optind++];
    yuvFileName = argv[optind++];

    /* warn about extraneous non-option arguments */
    if (optind < argc) {
        fprintf(stderr, "%s: unknown options specified, ignoring: ");
        while (optind < argc) {
            fprintf(stderr, "%s ", argv[optind++]);
        }
        fprintf(stderr, "\n");
    }

    /* end processing of command line */

    /* open the RGB file */
    rgbFile = fopen(rgbFileName, "rb");
    if (rgbFile == NULL) {
        fprintf(stderr, 
            "%s: error %s: %s\n",
            progName, rgbFileName, strerror(errno));
        exit(4);
    }

    /* open the RAW file */
    yuvFile = fopen(yuvFileName, "wb");
    if (yuvFile == NULL) {
        fprintf(stderr,
            "%s: error opening %s: %s\n",
            progName, yuvFileName, strerror(errno));
        exit(5);
    }

    /* get an input buffer for a frame */
    rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

    /* get the output buffers for a frame */
    yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
    uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

    if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL) {
        fprintf(stderr,
            "%s: error allocating memory: %s\n",
            progName, strerror(errno));
        exit(6);
    }

    while (fread(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile)) {

        RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip);

        fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);
        fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
        fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);

        videoFramesWritten++;
    }

    printf("%u %ux%u video frames written\n", 
        videoFramesWritten, frameWidth, frameHeight);

    /* cleanup */
    fclose(rgbFile);
    fclose(yuvFile);

    return(0);
}