/*

 * Templates for image convertion routines

 * Copyright (c) 2001, 2002, 2003 Fabrice Bellard.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#ifndef RGB_OUT

#define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xffU)

#endif

static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,

                                        int width, int height)

{

    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;

    uint8_t *d, *d1, *d2;

    int w, y, cb, cr, r_add, g_add, b_add, width2;

    uint8_t *cm = cropTbl + MAX_NEG_CROP;

    unsigned int r, g, b;

    d = dst->data[0];

    y1_ptr = src->data[0];

    cb_ptr = src->data[1];

    cr_ptr = src->data[2];

    width2 = (width + 1) >> 1;

    for(;height >= 2; height -= 2) {

        d1 = d;

        d2 = d + dst->linesize[0];

        y2_ptr = y1_ptr + src->linesize[0];

        for(w = width; w >= 2; w -= 2) {

            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);

            /* output 4 pixels */

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);

            RGB_OUT(d1 + BPP, r, g, b);

            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);

            RGB_OUT(d2, r, g, b);

            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]);

            RGB_OUT(d2 + BPP, r, g, b);

            d1 += 2 * BPP;

            d2 += 2 * BPP;

            y1_ptr += 2;

            y2_ptr += 2;

            cb_ptr++;

            cr_ptr++;

        }

        /* handle odd width */

        if (w) {

            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]);

            RGB_OUT(d2, r, g, b);

            d1 += BPP;

            d2 += BPP;

            y1_ptr++;

            y2_ptr++;

            cb_ptr++;

            cr_ptr++;

        }

        d += 2 * dst->linesize[0];

        y1_ptr += 2 * src->linesize[0] - width;

        cb_ptr += src->linesize[1] - width2;

        cr_ptr += src->linesize[2] - width2;

    }

    /* handle odd height */

    if (height) {

        d1 = d;

        for(w = width; w >= 2; w -= 2) {

            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);

            /* output 2 pixels */

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]);

            RGB_OUT(d1 + BPP, r, g, b);

            d1 += 2 * BPP;

            y1_ptr += 2;

            cb_ptr++;

            cr_ptr++;

        }

        /* handle width */

        if (w) {

            YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]);

            YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            d1 += BPP;

            y1_ptr++;

            cb_ptr++;

            cr_ptr++;

        }

    }

}

static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,

                                         int width, int height)

{

    const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr;

    uint8_t *d, *d1, *d2;

    int w, y, cb, cr, r_add, g_add, b_add, width2;

    uint8_t *cm = cropTbl + MAX_NEG_CROP;

    unsigned int r, g, b;

    d = dst->data[0];

    y1_ptr = src->data[0];

    cb_ptr = src->data[1];

    cr_ptr = src->data[2];

    width2 = (width + 1) >> 1;

    for(;height >= 2; height -= 2) {

        d1 = d;

        d2 = d + dst->linesize[0];

        y2_ptr = y1_ptr + src->linesize[0];

        for(w = width; w >= 2; w -= 2) {

            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);

            /* output 4 pixels */

            YUV_TO_RGB2(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2(r, g, b, y1_ptr[1]);

            RGB_OUT(d1 + BPP, r, g, b);

            YUV_TO_RGB2(r, g, b, y2_ptr[0]);

            RGB_OUT(d2, r, g, b);

            YUV_TO_RGB2(r, g, b, y2_ptr[1]);

            RGB_OUT(d2 + BPP, r, g, b);

            d1 += 2 * BPP;

            d2 += 2 * BPP;

            y1_ptr += 2;

            y2_ptr += 2;

            cb_ptr++;

            cr_ptr++;

        }

        /* handle odd width */

        if (w) {

            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);

            YUV_TO_RGB2(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2(r, g, b, y2_ptr[0]);

            RGB_OUT(d2, r, g, b);

            d1 += BPP;

            d2 += BPP;

            y1_ptr++;

            y2_ptr++;

            cb_ptr++;

            cr_ptr++;

        }

        d += 2 * dst->linesize[0];

        y1_ptr += 2 * src->linesize[0] - width;

        cb_ptr += src->linesize[1] - width2;

        cr_ptr += src->linesize[2] - width2;

    }

    /* handle odd height */

    if (height) {

        d1 = d;

        for(w = width; w >= 2; w -= 2) {

            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);

            /* output 2 pixels */

            YUV_TO_RGB2(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            YUV_TO_RGB2(r, g, b, y1_ptr[1]);

            RGB_OUT(d1 + BPP, r, g, b);

            d1 += 2 * BPP;

            y1_ptr += 2;

            cb_ptr++;

            cr_ptr++;

        }

        /* handle width */

        if (w) {

            YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]);

            /* output 2 pixels */

            YUV_TO_RGB2(r, g, b, y1_ptr[0]);

            RGB_OUT(d1, r, g, b);

            d1 += BPP;

            y1_ptr++;

            cb_ptr++;

            cr_ptr++;

        }

    }

}

static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src,

                                        int width, int height)

{

    int wrap, wrap3, width2;

    int r, g, b, r1, g1, b1, w;

    uint8_t *lum, *cb, *cr;

    const uint8_t *p;

    lum = dst->data[0];

    cb = dst->data[1];

    cr = dst->data[2];

    width2 = (width + 1) >> 1;

    wrap = dst->linesize[0];

    wrap3 = src->linesize[0];

    p = src->data[0];

    for(;height>=2;height -= 2) {

        for(w = width; w >= 2; w -= 2) {

            RGB_IN(r, g, b, p);

            r1 = r;

            g1 = g;

            b1 = b;

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            RGB_IN(r, g, b, p + BPP);

            r1 += r;

            g1 += g;

            b1 += b;

            lum[1] = RGB_TO_Y_CCIR(r, g, b);

            p += wrap3;

            lum += wrap;

            RGB_IN(r, g, b, p);

            r1 += r;

            g1 += g;

            b1 += b;

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            RGB_IN(r, g, b, p + BPP);

            r1 += r;

            g1 += g;

            b1 += b;

            lum[1] = RGB_TO_Y_CCIR(r, g, b);

            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2);

            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2);

            cb++;

            cr++;

            p += -wrap3 + 2 * BPP;

            lum += -wrap + 2;

        }

        if (w) {

            RGB_IN(r, g, b, p);

            r1 = r;

            g1 = g;

            b1 = b;

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            p += wrap3;

            lum += wrap;

            RGB_IN(r, g, b, p);

            r1 += r;

            g1 += g;

            b1 += b;

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);

            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);

            cb++;

            cr++;

            p += -wrap3 + BPP;

            lum += -wrap + 1;

        }

        p += wrap3 + (wrap3 - width * BPP);

        lum += wrap + (wrap - width);

        cb += dst->linesize[1] - width2;

        cr += dst->linesize[2] - width2;

    }

    /* handle odd height */

    if (height) {

        for(w = width; w >= 2; w -= 2) {

            RGB_IN(r, g, b, p);

            r1 = r;

            g1 = g;

            b1 = b;

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            RGB_IN(r, g, b, p + BPP);

            r1 += r;

            g1 += g;

            b1 += b;

            lum[1] = RGB_TO_Y_CCIR(r, g, b);

            cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1);

            cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1);

            cb++;

            cr++;

            p += 2 * BPP;

           lum += 2;

        }

        if (w) {

            RGB_IN(r, g, b, p);

            lum[0] = RGB_TO_Y_CCIR(r, g, b);

            cb[0] = RGB_TO_U_CCIR(r, g, b, 0);

            cr[0] = RGB_TO_V_CCIR(r, g, b, 0);

        }

    }

}

static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src,

                                     int width, int height)

{

    const unsigned char *p;

    unsigned char *q;

    int r, g, b, dst_wrap, src_wrap;

    int x, y;

    p = src->data[0];

    src_wrap = src->linesize[0] - BPP * width;

    q = dst->data[0];

    dst_wrap = dst->linesize[0] - width;

    for(y=0;y<height;y++) {

        for(x=0;x<width;x++) {

            RGB_IN(r, g, b, p);

            q[0] = RGB_TO_Y(r, g, b);

            q++;

            p += BPP;

        }

        p += src_wrap;

        q += dst_wrap;

    }

}

static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,

                                     int width, int height)

{

    const unsigned char *p;

    unsigned char *q;

    int r, dst_wrap, src_wrap;

    int x, y;

    p = src->data[0];

    src_wrap = src->linesize[0] - width;

    q = dst->data[0];

    dst_wrap = dst->linesize[0] - BPP * width;

    for(y=0;y<height;y++) {

        for(x=0;x<width;x++) {

            r = p[0];

            RGB_OUT(q, r, r, r);

            q += BPP;

            p ++;

        }

        p += src_wrap;

        q += dst_wrap;

    }

}

static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,

                                     int width, int height)

{

    const unsigned char *p;

    unsigned char *q;

    int r, g, b, dst_wrap, src_wrap;

    int x, y;

    uint32_t v;

    const uint32_t *palette;

    p = src->data[0];

    src_wrap = src->linesize[0] - width;

    palette = (uint32_t *)src->data[1];

    q = dst->data[0];

    dst_wrap = dst->linesize[0] - BPP * width;

    for(y=0;y<height;y++) {

        for(x=0;x<width;x++) {

            v = palette[p[0]];

            r = (v >> 16) & 0xff;

            g = (v >> 8) & 0xff;

            b = (v) & 0xff;

#ifdef RGBA_OUT

            {

                int a;

                a = (v >> 24) & 0xff;

                RGBA_OUT(q, r, g, b, a);

            }

#else

            RGB_OUT(q, r, g, b);

#endif

            q += BPP;

            p ++;

        }

        p += src_wrap;

        q += dst_wrap;

    }

}

#if !defined(FMT_RGBA32) && defined(RGBA_OUT)

/* alpha support */

static void glue(rgba32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src,

                                      int width, int height)

{

    const uint8_t *s;

    uint8_t *d;

    int src_wrap, dst_wrap, j, y;

    unsigned int v, r, g, b, a;

    s = src->data[0];

    src_wrap = src->linesize[0] - width * 4;

    d = dst->data[0];

    dst_wrap = dst->linesize[0] - width * BPP;

    for(y=0;y<height;y++) {

        for(j = 0;j < width; j++) {

            v = ((const uint32_t *)(s))[0];

            a = (v >> 24) & 0xff;

            r = (v >> 16) & 0xff;

            g = (v >> 8) & 0xff;

            b = v & 0xff;

            RGBA_OUT(d, r, g, b, a);

            s += 4;

            d += BPP;

        }

        s += src_wrap;

        d += dst_wrap;

    }

}

static void glue(RGB_NAME, _to_rgba32)(AVPicture *dst, const AVPicture *src,

                                       int width, int height)

{

    const uint8_t *s;

    uint8_t *d;

    int src_wrap, dst_wrap, j, y;

    unsigned int r, g, b, a;

    s = src->data[0];

    src_wrap = src->linesize[0] - width * BPP;

    d = dst->data[0];

    dst_wrap = dst->linesize[0] - width * 4;

    for(y=0;y<height;y++) {

        for(j = 0;j < width; j++) {

            RGBA_IN(r, g, b, a, s);

            ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;

            d += 4;

            s += BPP;

        }

        s += src_wrap;

        d += dst_wrap;

    }

}

#endif /* !defined(FMT_RGBA32) && defined(RGBA_OUT) */

#if defined(FMT_RGBA32)

#if !defined(rgba32_fcts_done)

#define rgba32_fcts_done

static void ayuv4444_to_rgba32(AVPicture *dst, const AVPicture *src,

                             int width, int height)

{

    uint8_t *s, *d, *d1, *s1;

    int w, y, cb, cr, r_add, g_add, b_add;

    uint8_t *cm = cropTbl + MAX_NEG_CROP;

    unsigned int r, g, b, a;

    d = dst->data[0];

    s = src->data[0];

    for(;height > 0; height --) {

        d1 = d;

        s1 = s;

        for(w = width; w > 0; w--) {

            a = s1[0];

            YUV_TO_RGB1_CCIR(s1[2], s1[3]);

            YUV_TO_RGB2_CCIR(r, g, b, s1[1]);

            RGBA_OUT(d1, r, g, b, a);

            d1 += BPP;

            s1 += 4;

        }

        d += dst->linesize[0];

        s += src->linesize[0];

    }

}

static void rgba32_to_ayuv4444(AVPicture *dst, const AVPicture *src,

                             int width, int height)

{

    int src_wrap, dst_wrap, x, y;

    int r, g, b, a;

    uint8_t *d;

    const uint8_t *p;

    src_wrap = src->linesize[0] - width * BPP;

    dst_wrap = dst->linesize[0] - width * 4;

    d = dst->data[0];

    p = src->data[0];

    for(y=0;y<height;y++) {

        for(x=0;x<width;x++) {

            RGBA_IN(r, g, b, a, p);

            d[0] = a;

            d[1] = RGB_TO_Y_CCIR(r, g, b);

            d[2] = RGB_TO_U_CCIR(r, g, b, 0);

            d[3] = RGB_TO_V_CCIR(r, g, b, 0);

            p += BPP;

            d += 4;

        }

        p += src_wrap;

        d += dst_wrap;

    }