• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>

    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>

            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            

    
            

            




            







												


        


            


            牽著老婆滿街逛
            

            嚴以律己,寬以待人. 三思而后行.
            
GMail/GTalk: yanglinbo#google.com;
            
MSN/Email: tx7do#yahoo.com.cn;
            
QQ: 3 0 3 3 9 6 9 2 0 .
            

            




            
	
					
	
            
		
            
			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);
            }


            
		
            
			posted on 2013-01-24 23:47 楊粼波 閱讀(1243) 評論(0)  編輯 收藏 引用  
		
            
	
            
	
	





            
	    
    




            






            

				

            



    
    







            
	   
	



国产精品美女久久久久av爽|
久久青青国产|
99久久国产宗和精品1上映|
久久狠狠一本精品综合网|
久久青青草原精品影院|
久久香综合精品久久伊人|
亚洲va久久久噜噜噜久久男同
|
一本色道久久88—综合亚洲精品|
午夜肉伦伦影院久久精品免费看国产一区二区三区
|
久久青青草原精品国产软件|
久久国产福利免费|
精品久久国产一区二区三区香蕉|
久久精品国产亚洲沈樵|
韩国无遮挡三级久久|
久久国产精品成人免费|
久久精品国产亚洲欧美|
品成人欧美大片久久国产欧美|
国产福利电影一区二区三区久久久久成人精品综合
|
久久久久国产精品嫩草影院|
麻豆久久久9性大片|
色妞色综合久久夜夜|
亚洲精品白浆高清久久久久久|
狠狠综合久久综合88亚洲
|
国内精品久久久久影院一蜜桃|
AV狠狠色丁香婷婷综合久久
|
怡红院日本一道日本久久|
久久久久久久久久免免费精品
|
久久久国产99久久国产一|
亚洲午夜久久久久久久久久|
国产成人久久精品区一区二区|
亚洲一区中文字幕久久|
久久精品无码一区二区三区免费|
亚洲国产成人精品无码久久久久久综合
|
www久久久天天com|
久久九九久精品国产免费直播|
亚洲国产天堂久久久久久|
亚洲va中文字幕无码久久|
日韩一区二区久久久久久
|
精品久久久无码人妻中文字幕
|
久久激情亚洲精品无码?V|
久久久SS麻豆欧美国产日韩|