imgconvert.c

64-bits H.264 from ffmpeg 2008 version Build in VC++ 2008 no error warning, Jesse Stone, Taiwan

    int mask,ret;
    mask = (1 << n) - 1;
    ret = a;
	//return (a & (0xff & ~mask)) | ((-((a >> n) & 1)) & mask);
	return (ret & (0xff & ~mask)) | ((-((ret >> n) & 1)) & mask);
}*/

/* rgb555 handling */

/*#define RGB_NAME_00 rgb555

#define RGB_IN(r, g, b, s)\
{\
    unsigned int v = ((const uint16_t *)(s))[0];\
    r = bitcopy_n(v >> (10 - 3), 3);\
    g = bitcopy_n(v >> (5 - 3), 3);\
    b = bitcopy_n(v << 3, 3);\
}


#define RGB_OUT(d, r, g, b)\
{\
    ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);\
}*/

//#define BPP 2

//#include "imgconvert_template.h"

/* rgb565 handling */

/*#define RGB_NAME_01 rgb565

#define RGB_IN(r, g, b, s)\
{\
    unsigned int v = ((const uint16_t *)(s))[0];\
    r = bitcopy_n(v >> (11 - 3), 3);\
    g = bitcopy_n(v >> (5 - 2), 2);\
    b = bitcopy_n(v << 3, 3);\
}

#define RGB_OUT(d, r, g, b)\
{\
    ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
}*/

//#define BPP 2

//#include "imgconvert_template.h"

/* bgr24 handling */

/*#define RGB_NAME_02 bgr24

#define RGB_IN(r, g, b, s)\
{\
    b = (s)[0];\
    g = (s)[1];\
    r = (s)[2];\
}

#define RGB_OUT(d, r, g, b)\
{\
    (d)[0] = b;\
    (d)[1] = g;\
    (d)[2] = r;\
}*/

//#define BPP 3

//#include "imgconvert_template.h"

//#undef RGB_IN
//#undef RGB_OUT
//#undef BPP

/* rgb24 handling */

#define RGB_NAME_03 rgb24
#define FMT_RGB24

/*#define RGB_IN(r, g, b, s)\
{\
    r = (s)[0];\
    g = (s)[1];\
    b = (s)[2];\
}*/

#define RGB_OUT(d, r, g, b)\
{\
    (d)[0] = r;\
    (d)[1] = g;\
    (d)[2] = b;\
}

#define BPP 3

//#include "imgconvert_template.h"

/* rgb32 handling */

#define RGB_NAME_04 rgb32
#define FMT_RGB32

/*#define RGB_IN(r, g, b, s)\
{\
    unsigned int v = ((const uint32_t *)(s))[0];\
    r = (v >> 16) & 0xff;\
    g = (v >> 8) & 0xff;\
    b = v & 0xff;\
}

#define RGBA_IN(r, g, b, a, s)\
{\
    unsigned int v = ((const uint32_t *)(s))[0];\
    a = (v >> 24) & 0xff;\
    r = (v >> 16) & 0xff;\
    g = (v >> 8) & 0xff;\
    b = v & 0xff;\
}

#define RGBA_OUT(d, r, g, b, a)\
{\
    ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;\
}*/

//#define BPP 4

//#include "imgconvert_template.h"
/*
static void mono_to_gray(AVPicture *dst, const AVPicture *src,
                         int width, int height, int xor_mask)
{
    const unsigned char *p;
    unsigned char *q;
    int v, dst_wrap, src_wrap;
    int y, w;

    p = src->data[0];
    src_wrap = src->linesize[0] - ((width + 7) >> 3);

    q = dst->data[0];
    dst_wrap = dst->linesize[0] - width;
    for(y=0;y<height;y++) {
        w = width;
        while (w >= 8) {
            v = *p++ ^ xor_mask;
            q[0] = -(v >> 7);
            q[1] = -((v >> 6) & 1);
            q[2] = -((v >> 5) & 1);
            q[3] = -((v >> 4) & 1);
            q[4] = -((v >> 3) & 1);
            q[5] = -((v >> 2) & 1);
            q[6] = -((v >> 1) & 1);
            q[7] = -((v >> 0) & 1);
            w -= 8;
            q += 8;
        }
        if (w > 0) {
            v = *p++ ^ xor_mask;
            do {
                q[0] = -((v >> 7) & 1);
                q++;
                v <<= 1;
            } while (--w);
        }
        p += src_wrap;
        q += dst_wrap;
    }
}

static void monowhite_to_gray(AVPicture *dst, const AVPicture *src,
                               int width, int height)
{
    mono_to_gray(dst, src, width, height, 0xff);
}

static void monoblack_to_gray(AVPicture *dst, const AVPicture *src,
                               int width, int height)
{
    mono_to_gray(dst, src, width, height, 0x00);
}

static void gray_to_mono(AVPicture *dst, const AVPicture *src,
                         int width, int height, int xor_mask)
{
    int n;
    const uint8_t *s;
    uint8_t *d;
    int j, b, v, n1, src_wrap, dst_wrap, y;

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

    d = dst->data[0];
    dst_wrap = dst->linesize[0] - ((width + 7) >> 3);

    for(y=0;y<height;y++) {
        n = width;
        while (n >= 8) {
            v = 0;
            for(j=0;j<8;j++) {
                b = s[0];
                s++;
                v = (v << 1) | (b >> 7);
            }
            d[0] = v ^ xor_mask;
            d++;
            n -= 8;
        }
        if (n > 0) {
            n1 = n;
            v = 0;
            while (n > 0) {
                b = s[0];
                s++;
                v = (v << 1) | (b >> 7);
                n--;
            }
            d[0] = (v << (8 - (n1 & 7))) ^ xor_mask;
            d++;
        }
        s += src_wrap;
        d += dst_wrap;
    }
}

static void gray_to_monowhite(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    gray_to_mono(dst, src, width, height, 0xff);
}

static void gray_to_monoblack(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    gray_to_mono(dst, src, width, height, 0x00);
}

static void gray_to_gray16(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    int x, y, src_wrap, dst_wrap;
    uint8_t *s, *d;
    s = src->data[0];
    src_wrap = src->linesize[0] - width;
    d = dst->data[0];
    dst_wrap = dst->linesize[0] - width * 2;
    for(y=0; y<height; y++){
        for(x=0; x<width; x++){
            *d++ = *s;
            *d++ = *s++;
        }
        s += src_wrap;
        d += dst_wrap;
    }
}

static void gray16_to_gray(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    int x, y, src_wrap, dst_wrap;
    uint8_t *s, *d;
    s = src->data[0];
    src_wrap = src->linesize[0] - width * 2;
    d = dst->data[0];
    dst_wrap = dst->linesize[0] - width;
    for(y=0; y<height; y++){
        for(x=0; x<width; x++){
            *d++ = *s;
            s += 2;
        }
        s += src_wrap;
        d += dst_wrap;
    }
}

static void gray16be_to_gray(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    gray16_to_gray(dst, src, width, height);
}

static void gray16le_to_gray(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    AVPicture tmpsrc = *src;
    tmpsrc.data[0]++;
    gray16_to_gray(dst, &tmpsrc, width, height);
}

static void gray16_to_gray16(AVPicture *dst, const AVPicture *src,
                              int width, int height)
{
    int x, y, src_wrap, dst_wrap;
    uint16_t *s, *d;
    s = (uint16_t*)src->data[0];
    src_wrap = (src->linesize[0] - width * 2)/2;
    d = (uint16_t*)dst->data[0];
    dst_wrap = (dst->linesize[0] - width * 2)/2;
    for(y=0; y<height; y++){
        for(x=0; x<width; x++){
            *d++ = bswap_16(*s++);
        }
        s += src_wrap;
        d += dst_wrap;
    }
}*/


typedef struct ConvertEntry 
{
    void (*convert)(AVPicture *dst, const AVPicture *src, int width, int height);
} ConvertEntry;

/* Add each new conversion function in this table. In order to be able
   to convert from any format to any format, the following constraints
   must be satisfied:

   - all FF_COLOR_RGB formats must convert to and from PIX_FMT_RGB24

   - all FF_COLOR_GRAY formats must convert to and from PIX_FMT_GRAY8

   - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGB32

   - PIX_FMT_YUV444P and PIX_FMT_YUVJ444P must convert to and from
     PIX_FMT_RGB24.

   - PIX_FMT_422 must convert to and from PIX_FMT_422P.

   The other conversion functions are just optimizations for common cases.
*/
static const ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB];
// = {
//    [PIX_FMT_YUV420P] = {
//        [PIX_FMT_YUYV422] = {
//            .convert = yuv420p_to_yuyv422,
//        },
//        [PIX_FMT_RGB555] = {
//            .convert = yuv420p_to_rgb555
//        },
//        [PIX_FMT_RGB565] = {
//            .convert = yuv420p_to_rgb565
//        },
//        [PIX_FMT_BGR24] = {
//            .convert = yuv420p_to_bgr24
//        },
//        [PIX_FMT_RGB24] = {
//            .convert = yuv420p_to_rgb24
//        },
//        [PIX_FMT_RGB32] = {
//            .convert = yuv420p_to_rgb32
//        },
//        [PIX_FMT_UYVY422] = {
//            .convert = yuv420p_to_uyvy422,
//        },
//    },
//    [PIX_FMT_YUV422P] = {
//        [PIX_FMT_YUYV422] = {
//            .convert = yuv422p_to_yuyv422,
//        },
//        [PIX_FMT_UYVY422] = {
//            .convert = yuv422p_to_uyvy422,
//        },
//    },
//    [PIX_FMT_YUV444P] = {
//        [PIX_FMT_RGB24] = {
//            .convert = yuv444p_to_rgb24
//        },
//    },
//    [PIX_FMT_YUVJ420P] = {
//        [PIX_FMT_RGB555] = {
//            .convert = yuvj420p_to_rgb555
//        },
//        [PIX_FMT_RGB565] = {
//            .convert = yuvj420p_to_rgb565
//        },
//        [PIX_FMT_BGR24] = {
//            .convert = yuvj420p_to_bgr24
//        },
//        [PIX_FMT_RGB24] = {
//            .convert = yuvj420p_to_rgb24
//        },
//        [PIX_FMT_RGB32] = {
//            .convert = yuvj420p_to_rgb32
//        },
//    },
//    [PIX_FMT_YUVJ444P] = {
//        [PIX_FMT_RGB24] = {
//            .convert = yuvj444p_to_rgb24
//        },
//    },
//    [PIX_FMT_YUYV422] = {
//        [PIX_FMT_YUV420P] = {
//            .convert = yuyv422_to_yuv420p,
//        },
//        [PIX_FMT_YUV422P] = {
//            .convert = yuyv422_to_yuv422p,
//        },
//    },
//    [PIX_FMT_UYVY422] = {
//        [PIX_FMT_YUV420P] = {
//            .convert = uyvy422_to_yuv420p,
//        },
//        [PIX_FMT_YUV422P] = {
//            .convert = uyvy422_to_yuv422p,
//        },
//    },
//    [PIX_FMT_RGB24] = {
//        [PIX_FMT_YUV420P] = {
//            .convert = rgb24_to_yuv420p
//        },
//        [PIX_FMT_RGB565] = {
//            .convert = rgb24_to_rgb565
//        },
//        [PIX_FMT_RGB555] = {
//            .convert = rgb24_to_rgb555
//        },
//        [PIX_FMT_RGB32] = {
//            .convert = rgb24_to_rgb32
//        },
//        [PIX_FMT_BGR24] = {
//            .convert = rgb24_to_bgr24
//        },
//        [PIX_FMT_GRAY8] = {
//            .convert = rgb24_to_gray
//        },
//        [PIX_FMT_PAL8] = {
//            .convert = rgb24_to_pal8
//        },
//        [PIX_FMT_YUV444P] = {
//            .convert = rgb24_to_yuv444p
//        },
//        [PIX_FMT_YUVJ420P] = {
//            .convert = rgb24_to_yuvj420p
//        },
//        [PIX_FMT_YUVJ444P] = {
//            .convert = rgb24_to_yuvj444p
//        },
//    },
//    [PIX_FMT_RGB32] = {
//        [PIX_FMT_RGB24] = {
//            .convert = rgb32_to_rgb24
//        },
//        [PIX_FMT_BGR24] = {
//            .convert = rgb32_to_bgr24
//        },
//        [PIX_FMT_RGB565] = {
//            .convert = rgb32_to_rgb565
//        },
//        [PIX_FMT_RGB555] = {
//            .convert = rgb32_to_rgb555
//        },
//        [PIX_FMT_PAL8] = {
//            .convert = rgb32_to_pal8
//        },
//        [PIX_FMT_YUV420P] = {
//            .convert = rgb32_to_yuv420p
//        },
//        [PIX_FMT_GRAY8] = {
//            .convert = rgb32_to_gray
//        },
//    },
//    [PIX_FMT_BGR24] = {
//        [PIX_FMT_RGB32] = {
//            .convert = bgr24_to_rgb32
//        },
//        [PIX_FMT_RGB24] = {