yuv2rgb.c

linux下的一款播放器

        PIXEL(df,a11); PIXEL(df,a12);                       \
        PIXEL(df,a21); PIXEL(df,a22);                       \
        YUV_LOAD_CONVERT_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
        sy1+=2; sy2+=2; su++; sv++;                         \
        STORE(df,d1,a11);                                   \
        STORE(df,d1+BPP(df),a12);                           \
        d1+=2*BPP(df);                                      \
        STORE(df,d2,a21);                                   \
        STORE(df,d2+BPP(df),a22);                           \
        d2+=2*BPP(df);                                      \
    }

#define YUV_LOAD_CONVERT_DITHER_STORE_2x2(cc,df,d1,d2,sy1,sy2,su,sv) \
    {                                                       \
        PIXEL(df,a11); PIXEL(df,a12);                       \
        PIXEL(df,a21); PIXEL(df,a22);                       \
        YUV_LOAD_CONVERT_DITHER_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
        sy1+=2; sy2+=2; su++; sv++;                         \
        STORE(df,d1,a11);                                   \
        STORE(df,d1+BPP(df),a12);                           \
        d1+=2*BPP(df);                                      \
        STORE(df,d2,a21);                                   \
        STORE(df,d2+BPP(df),a22);                           \
        d2+=2*BPP(df);                                      \
    }

/*
 * Generic YUV load-convert-average-store macros:
 *  [d1],[d2] = convert([s1],[s2]);
 *  [d01] = ([d0]+[d1])/2;
 *  [d12] = ([d1]+[d2])/2;
 */
#define YUV_LOAD_CONVERT_AVERAGE_STORE_2x1(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
    {                                                       \
        PIXEL(df,a1); PIXEL(df,a2);                         \
        YUV_LOAD_CONVERT_2x1(cc,df,a1,a2,sy1,sy2,su,sv);    \
        sy1++; sy2++; su++; sv++;                           \
        STORE(df,d1,a1);                                    \
        d1+=BPP(df);                                        \
        STORE(df,d2,a2);                                    \
        d2+=BPP(df);                                        \
        AVERAGE(df,a2,a1,a2);                               \
        LOAD_AVERAGE(df,a1,a1,d0);                          \
        d0+=BPP(df);                                        \
        STORE(df,d01,a1);                                   \
        d01+=BPP(df);                                       \
        STORE(df,d12,a2);                                   \
        d12+=BPP(df);                                       \
    }

#define YUV_LOAD_CONVERT_AVERAGE_STORE_2x2(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
    {                                                       \
        PIXEL(df,a11); PIXEL(df,a12);                       \
        PIXEL(df,a21); PIXEL(df,a22);                       \
        YUV_LOAD_CONVERT_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
        sy1+=2; sy2+=2; su++; sv++;                         \
        STORE(df,d1,a11);                                   \
        STORE(df,d1+BPP(df),a12);                           \
        d1+=2*BPP(df);                                      \
        STORE(df,d2,a21);                                   \
        STORE(df,d2+BPP(df),a22);                           \
        d2+=2*BPP(df);                                      \
        AVERAGE(df,a21,a11,a21);                            \
        AVERAGE(df,a22,a12,a22);                            \
        LOAD_AVERAGE(df,a11,a11,d0);                        \
        LOAD_AVERAGE(df,a12,a12,d0+BPP(df));                \
        d0+=2*BPP(df);                                      \
        STORE(df,d01,a11);                                  \
        STORE(df,d01+BPP(df),a12);                          \
        d01+=2*BPP(df);                                     \
        STORE(df,d12,a21);                                  \
        STORE(df,d12+BPP(df),a22);                          \
        d12+=2*BPP(df);                                     \
    }

#define YUV_LOAD_CONVERT_AVERAGE_DITHER_STORE_2x2(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
    {                                                       \
        PIXEL(df,a11); PIXEL(df,a12);                       \
        PIXEL(df,a21); PIXEL(df,a22);                       \
        YUV_LOAD_CONVERT_DITHER_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
        sy1+=2; sy2+=2; su++; sv++;                         \
        STORE(df,d1,a11);                                   \
        STORE(df,d1+BPP(df),a12);                           \
        d1+=2*BPP(df);                                      \
        STORE(df,d2,a21);                                   \
        STORE(df,d2+BPP(df),a22);                           \
        d2+=2*BPP(df);                                      \
        AVERAGE(df,a21,a11,a21);                            \
        AVERAGE(df,a22,a12,a22);                            \
        LOAD_AVERAGE(df,a11,a11,d0);                        \
        LOAD_AVERAGE(df,a12,a12,d0+BPP(df));                \
        d0+=2*BPP(df);                                      \
        STORE(df,d01,a11);                                  \
        STORE(df,d01+BPP(df),a12);                          \
        d01+=2*BPP(df);                                     \
        STORE(df,d12,a21);                                  \
        STORE(df,d12+BPP(df),a22);                          \
        d12+=2*BPP(df);                                     \
    }

/*** Generic YUVtoRGB double-row converters: ***************/

/*
 * Generic YUVtoRGB double-row shrinking converter:
 *  uses read-ahead optimization to process full 2x2 blocks
 *  whenever possible.
 */
#define DBLROW_SHRINK(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
    {                                                       \
        /* initialize local variables: */                   \
        register int count = dest_dx;                       \
        register int limit = src_dx >> 1; /* -1 */          \
        register int step = dest_dx;                        \
        /* check row length: */                             \
        if (count) {                                        \
            /* check if we have an odd first block: */      \
            if (src_x & 1)                                  \
                goto start_odd;                             \
            /* process even pixels: */                      \
            do {                                            \
                PIXEL(df,a11); PIXEL(df,a12);               \
                PIXEL(df,a21); PIXEL(df,a22);               \
                /* make one Bresenham step ahead: */        \
                if ((limit -= step) < 0) {                  \
                    limit += src_dx;                        \
                    /* can we process 2x2 pixels? */        \
                    if (!--count)                           \
                        goto last_pixel;                    \
                    /* process full 2x2 block: */           \
                    YUV_LOAD_CONVERT_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
                    sy1+=2; sy2+=2; su++; sv++;             \
                    STORE(df,d1,a11);                       \
                    STORE(df,d1+BPP(df),a12);               \
                    d1+=2*BPP(df);                          \
                    STORE(df,d2,a21);                       \
                    STORE(df,d2+BPP(df),a22);               \
                    d2+=2*BPP(df);                          \
                } else {                                    \
                    /* proc. first 2x1 block & skip next: */\
                    YUV_LOAD_CONVERT_2x1(cc,df,a11,a21,sy1,sy2,su,sv); \
                    sy1+=2; sy2+=2; su++; sv++;             \
                    STORE(df,d1,a11);                       \
                    d1+=BPP(df);                            \
                    STORE(df,d2,a21);                       \
                    d2+=BPP(df);                            \
                }                                           \
                /* inverted Bresenham stepping: */          \
                while ((limit -= step) >= 0) {              \
                    /* skip next even source pixel: */      \
                    sy1++; sy2++;                           \
                    if ((limit -= step) < 0)                \
                        goto cont_odd;                      \
                    /* skip odd source pixel: */            \
                    sy1++; sy2++;                           \
                    su++; sv++; /* next chroma: */          \
                }                                           \
cont_even:      /* continue loop with next even pixel: */   \
                limit += src_dx;                            \
            } while (--count);                              \
            goto done;                                      \
last_pixel: /* use this branch to process last pixel:*/     \
            count++;                                        \
start_odd:  /* process odd pixels: */                       \
            do {                                            \
                PIXEL(df,a11); PIXEL(df,a21);               \
                YUV_LOAD_CONVERT_2x1(cc,df,a11,a21,sy1,sy2,su,sv); \
                STORE(df,d1,a11);                           \
                d1+=BPP(df);                                \
                STORE(df,d2,a21);                           \
                d2+=BPP(df);                                \
                /* inverted Bresenham stepping: */          \
                do {                                        \
                    /* skip odd source pixel: */            \
                    sy1++; sy2++;                           \
                    su++; sv++; /* next chroma: */          \
                    if ((limit -= step) < 0)                \
                        goto cont_even;                     \
                    /* skip even source pixel: */           \
                    sy1++; sy2++;                           \
                } while ((limit -= step) >= 0);             \
cont_odd:       limit += src_dx;                            \
            } while (--count);                              \
done:       ;                                               \
        }                                                   \
    }

/*
 * Generic YUVtoRGB double-row copy converter:
 */
#define DBLROW_COPY(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
    {                                                       \
        register int count = dest_dx;                       \
        /* convert first 2x1 block: */                      \
        if ((src_x & 1) && count) {                         \
            YUV_LOAD_CONVERT_STORE_2x1(cc,df,d1,d2,sy1,sy2,su,sv); \
            count--;                                        \
        }                                                   \
        /* convert all integral 2x2 blocks: */              \
        while (count >= 2) {                                \
            YUV_LOAD_CONVERT_DITHER_STORE_2x2(cc,df,d1,d2,sy1,sy2,su,sv); \
            count -= 2;                                     \
        }                                                   \
        /* convert last 2x1 block: */                       \
        if (count) {                                        \
            YUV_LOAD_CONVERT_STORE_2x1(cc,df,d1,d2,sy1,sy2,su,sv); \
        }                                                   \
    }


/*
 * Generic YUVtoRGB double row stretching converter:
 */
#define DBLROW_STRETCH(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
    {                                                       \
        /* initialize local variables: */                   \
        register int count = dest_dx;                       \
        register int limit = dest_dx >> 1; /* !!! */        \
        register int step = src_dx;                         \
        /* # of pixels to be processed separately: */       \
        int remainder = dest_dx - limit;                    \
        if ((src_x + src_dx) & 1) remainder += dest_dx;     \
        remainder /= step;                                  \
        /* check row length: */                             \
        if (count) {                                        \
            PIXEL(df,a11); PIXEL(df,a12);                   \
            PIXEL(df,a21); PIXEL(df,a22);                   \
            /* update count: */                             \
            if ((count -= remainder) <= 0)                  \
                goto convert_last;                          \
            /* check if we have an odd first block: */      \
            if (src_x & 1) {                                \