rgb2rgb.c

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: rgb2rgb.c,v 1.5.8.1 2004/07/09 02:00:18 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

#ifdef _MACINTOSH
#pragma require_prototypes off
#endif

/*** #includes: ********************************************/

#include "env.h"
#include "rgb.h"    /* basic RGB-data definitions & macros */
#include "scale.h"  /* scale algorithms */
#include "colorlib.h" /* ensure that prototypes get extern C'ed */
/*** Additional pixel-level macros: ************************/

/*
 * Generic pixel load-convert-store macro:
 */
#define LOAD_CONVERT_STORE(df,d,sf,s)       \
    {                                       \
        PIXEL(df,da);                       \
        LOAD_CONVERT(df,da,sf,s);           \
        s+=BPP(sf);                         \
        STORE(df,d,da);                     \
        d+=BPP(df);                         \
    }

/*
 * Generic 4-pixels load-convert-store macro
 * (XXX: this is just a lazy implementation of
 *  4-times unrolled load-convert-store;
 *  later, we should rewrite it for better
 *  efficiency !!!)
 */
#define LOAD_CONVERT_STORE_4(df,d,sf,s)     \
    {                                       \
        PIXEL(df,da);                       \
        LOAD_CONVERT(df,da,sf,s);           \
        STORE(df,d,da);                     \
        LOAD_CONVERT(df,da,sf,s+BPP(sf));   \
        STORE(df,d+BPP(df),da);             \
        LOAD_CONVERT(df,da,sf,s+2*BPP(sf)); \
        STORE(df,d+2*BPP(df),da);           \
        LOAD_CONVERT(df,da,sf,s+3*BPP(sf)); \
        STORE(df,d+3*BPP(df),da);           \
        s+=4*BPP(sf);                       \
        d+=4*BPP(df);                       \
    }

/*
 * Generic pixel load-convert-average-store macro:
 * ([d2] = convert([s]); [d12] = ([d1]+[d2])/2)
 */
#define LOAD_CONVERT_AVERAGE_STORE(df,d1,d12,d2,sf,s) \
    {                                       \
        PIXEL(df,da);                       \
        LOAD_CONVERT(df,da,sf,s);           \
        s+=BPP(sf);                         \
        STORE(df,d2,da);                    \
        d2+=BPP(df);                        \
        LOAD_AVERAGE(df,da,da,d1);          \
        d1+=BPP(df);                        \
        STORE(df,d12,da);                   \
        d12+=BPP(df);                       \
    }

/*
 * Generic 4-pixels load-convert-average-store macro:
 * (again, very lazy implementation; ultimately it should
 *  be rewritten for all possible combinations of pixel formats !!)
 */
#define LOAD_CONVERT_AVERAGE_STORE_4(df,d1,d12,d2,sf,s) \
    {                                       \
        PIXEL(df,da);                       \
        /* first column: */                 \
        LOAD_CONVERT(df,da,sf,s);           \
        STORE(df,d2,da);                    \
        LOAD_AVERAGE(df,da,da,d1);          \
        STORE(df,d12,da);                   \
        /* second column: */                \
        LOAD_CONVERT(df,da,sf,s+BPP(sf));   \
        STORE(df,d2+BPP(df),da);            \
        LOAD_AVERAGE(df,da,da,d1+BPP(df));  \
        STORE(df,d12+BPP(df),da);           \
        /* third column: */                 \
        LOAD_CONVERT(df,da,sf,s+2*BPP(sf)); \
        STORE(df,d2+2*BPP(df),da);          \
        LOAD_AVERAGE(df,da,da,d1+2*BPP(df));\
        STORE(df,d12+2*BPP(df),da);         \
        /* fourth column: */                \
        LOAD_CONVERT(df,da,sf,s+3*BPP(sf)); \
        STORE(df,d2+3*BPP(df),da);          \
        LOAD_AVERAGE(df,da,da,d1+3*BPP(df));\
        STORE(df,d12+3*BPP(df),da);         \
        /* update pointers: */              \
        s +=4*BPP(sf);                      \
        d1+=4*BPP(df);                      \
        d2+=4*BPP(df);                      \
        d12+=4*BPP(df);                     \
    }


/*** Generic RGB single-row converters: ********************/

/*
 * Generic row shrinking converter:
 */
#define ROW_SHRINK(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)   \
    {                                                       \
        /* initialize local variables: */                   \
        register unsigned char *d = dest_ptr;               \
        register unsigned char *s = src_ptr;                \
        register int count = dest_dx;                       \
        register int limit = src_dx >> 1; /* -1 */          \
        register int step = dest_dx;                        \
        /* check row length: */                             \
        if (count) {                                        \
            do {                                            \
                /* convert and copy a nearest pixel: */     \
                PIXEL(df,da);                               \
                LOAD_CONVERT(df,da,sf,s);                   \
                STORE(df,d,da);                             \
                d+=BPP(df);                                 \
                /* inverted Bresenham stepping: */          \
                do {                                        \
                    /* skip source pixel: */                \
                    s+=BPP(sf);                             \
                } while ((limit -= step) >= 0);             \
                limit += src_dx;                            \
            } while (--count);                              \
        }                                                   \
    }

/*
 * Generic row copy converter:
 */
#define ROW_COPY(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)     \
    {                                                       \
        /* do we have the same format? */                   \
        if (ID(df) == ID(sf)) {                             \
            /* just use memcopy: */                         \
            memcpy(dest_ptr, src_ptr, dest_dx*BPP(df)); /* Flawfinder: ignore */    \
        } else {                                            \
            /* initialize local variables: */               \
            register unsigned char *d = dest_ptr;           \
            register unsigned char *s = src_ptr;            \
            register int count = dest_dx;                   \
            /* convert misaligned pixels first: */          \
            while (((unsigned int)d & 3)                    \
                && ((unsigned int)s & 3) && count) {        \
                LOAD_CONVERT_STORE(df,d,sf,s);              \
                count --;                                   \
            }                                               \
            /* the main loop (convert 4 pixels a time): */  \
            while (count >= 4) {                            \
                LOAD_CONVERT_STORE_4(df,d,sf,s);            \
                count -= 4;                                 \
            }                                               \
            /* convert the remaining pixels: */             \
            while (count) {                                 \
                LOAD_CONVERT_STORE(df,d,sf,s);              \
                count --;                                   \
            }                                               \
        }                                                   \
    }

/*
 * Generic row stretching converter:
 *  (shall not be used when dest_dx/2 >= src_dx!!!)
 */
#define ROW_STRETCH(df,dest_ptr,dest_dx,sf,src_ptr,src_dx)  \
    {                                                       \
        /* initialize local variables: */                   \
        register unsigned char *d = dest_ptr;               \
        register unsigned char *s = src_ptr;                \
        register int count = dest_dx;                       \
        register int limit = dest_dx >> 1; /* !!! */        \
        register int step = src_dx;                         \
        /* check row length: */                             \
        if (count) {                                        \
            goto start;                                     \
            /* the main loop: */                            \
            do {                                            \
                PIXEL(df,da);                               \
                /* Bresenham stepping: */                   \
                if ((limit -= step) < 0) {                  \
                    limit += dest_dx;                       \
                    /* load & convert pixel: */             \
    start:          LOAD_CONVERT(df,da,sf,s);               \
                    s+=BPP(sf);                             \
                }                                           \
                /* replicate pixel: */                      \
                STORE(df,d,da);                             \
                d+=BPP(df);                                 \
            } while (--count);                              \
        }                                                   \
    }

/*
 * Generic row 2x-stretching converter:
 */
#define ROW_STRETCH2X(df,dest_ptr,dest_dx,sf,src_ptr,src_dx) \
    {                                                       \
        /* initialize local variables: */                   \
        register unsigned char *d = dest_ptr;               \
        register unsigned char *s = src_ptr;                \
        register int count = src_dx;                        \
        /* check row length: */                             \
        if (count) {                                        \
            /* process first integral pixel: */             \
            PIXEL(df,da);                                   \
            LOAD_CONVERT(df,da,sf,s);                       \
            s+=BPP(sf);                                     \
            count --;                                       \
            STORE(df,d,da);                                 \
            d+=BPP(df);                                     \
            /* main loop (process 2 pixels a time): */      \
            while (count >= 2) {                            \
                /* load & convert second integral pixel: */ \
                PIXEL(df,db);                               \
                LOAD_CONVERT(df,db,sf,s);                   \
                /* calculate first half-pixel: */           \
                AVERAGE(df,da,da,db);                       \
                /* store both pixels: */                    \
                STORE(df,d,da);                             \
                STORE(df,d+BPP(df),db);                     \
                /* load & convert third integral pixel: */  \
                LOAD_CONVERT(df,da,sf,s+BPP(sf));           \
                /* calculate second half-pixel: */          \
                AVERAGE(df,db,db,da);                       \
                /* store both pixels: */                    \
                STORE(df,d+2*BPP(df),db);                   \
                STORE(df,d+3*BPP(df),da);                   \
                /* shift pointers: */                       \
                s+=2*BPP(sf);                               \
                d+=4*BPP(df);                               \
                count -= 2;                                 \
            }                                               \
            /* is there any more pixels to convert? */      \
            if (count) {                                    \
                /* load & convert last integral pixel: */   \
                PIXEL(df,db);                               \
                LOAD_CONVERT(df,db,sf,s);                   \
                /* calculate last half-pixel: */            \
                AVERAGE(df,da,da,db);                       \
                /* store pixels: */                         \
                STORE(df,d,da);                             \
                STORE(df,d+BPP(df),db);                     \
                STORE(df,d+2*BPP(df),db);                   \
            } else {                                        \
                /* replicate last pixel: */                 \
                STORE(df,d,da);                             \
            }                                               \
        }                                                   \
    }

/*
 * Generic row 2x+ stretching converter:
 */
#define ROW_STRETCH2XPLUS(df,dest_ptr,dest_dx,sf,src_ptr,src_dx) \
    {                                                       \
        /* initialize local variables: */                   \
        register unsigned char *d = dest_ptr;               \
        register unsigned char *s = src_ptr;                \
        register int count = dest_dx;                       \
        register int limit = dest_dx >> 1; /* !!! */        \
        register int step = src_dx << 1;  /* !!! */         \
        /* # of pixels mapped outside source image: */      \
        register int remainder = (2*dest_dx - limit) / step;\
        /* check row length: */                             \
        if (count) {                                        \
            /* load & convert first pixel: */               \
            PIXEL(df,da); PIXEL(df,db);                     \
            LOAD_CONVERT(df,da,sf,s);                       \
            s+=BPP(sf);                                     \
            /* update counter: */                           \
            if (!(count -= remainder))                      \
                goto end_of_row;                            \
            /* main loop: */                                \
            while (1) {                                     \
                /* replicate first integral pixel: */       \
                do {                                        \
                    STORE(df,d,da);                         \
                    d+=BPP(df);                             \
                    if (!(--count))                         \
                        goto end_of_row;                    \
                } while ((limit -= step) >= 0);             \
                limit += dest_dx;                           \
                /* load & convert second pixel: */          \
                LOAD_CONVERT(df,db,sf,s);                   \
                /* calc & replicate first half-pixel: */    \
                AVERAGE(df,da,da,db);                       \
                do {                                        \
                    STORE(df,d,da);                         \
                    d+=BPP(df);                             \
                    if (!(--count))                         \
                        goto end_of_row;                    \
                } while ((limit -= step) >= 0);             \
                limit += dest_dx;                           \
                /* replicate second integral pixel: */      \
                do {                                        \
                    STORE(df,d,db);                         \
                    d+=BPP(df);                             \
                    if (!(--count))                         \
                        goto end_of_row_2;                  \
                } while ((limit -= step) >= 0);             \
                limit += dest_dx;                           \
                /* load & convert third pixel: */           \
                LOAD_CONVERT(df,da,sf,s+BPP(sf));           \
                s+=2*BPP(sf);                               \
                /* calc & replicate second half-pixel: */   \
                AVERAGE(df,db,db,da);                       \
                do {                                        \
                    STORE(df,d,db);                         \
                    d+=BPP(df);                             \
                    if (!(--count))                         \
                        goto end_of_row_2;                  \
                } while ((limit -= step) >= 0);             \
                limit += dest_dx;                           \
            }                                               \
            /* replicate the remaining pixels: */           \
end_of_row_2: COPY(df,da,db);                               \