imgconvert.c

ffmpeg移植到symbian的全部源代码

#define BPP 2

#include "imgconvert_template.h"

/* rgb565 handling */

#define RGB_NAME 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 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 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 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] = {
#ifdef __CW32__
	{
		0,
		{yuv420p_to_yuyv422},
		{yuv420p_to_rgb24},
		{yuv420p_to_bgr24},
		0,0,
		{yuv420p_to_rgb32},
		0,0,0,
		{yuv420p_to_rgb565},
		{yuv420p_to_rgb555},
		0,0,0,0,0,0,0,0,0,
		{yuv420p_to_uyvy422},
	},
	{
	    {yuyv422_to_yuv420p},
	    0,0,0,
	    {yuyv422_to_yuv422p},
	},
	{
	    {rgb24_to_yuv420p},
	    0,0,
	    {rgb24_to_bgr24},
	    0,
	    {rgb24_to_yuv444p},
	    {rgb24_to_rgb32},
	    0,0,
	    {rgb24_to_rgb565},
	    {rgb24_to_rgb555},
	    {rgb24_to_gray},
	    0,0,
	    {rgb24_to_pal8},
	    {rgb24_to_yuvj420p},
	    0,
	    {rgb24_to_yuvj444p},
	},
	{
	    {bgr24_to_yuv420p},
	    0,
	    {bgr24_to_rgb24},
	    0,0,0,
	    {bgr24_to_rgb32},
	    0,0,0,0,
	    {bgr24_to_gray},
	},
	{
	    0,
	    {yuv422p_to_yuyv422},
	    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	    {yuv422p_to_uyvy422},
	},
	{
		0,0,
	    {yuv444p_to_rgb24},
	},
	{
	    {rgb32_to_yuv420p},
	    0,
	    {rgb32_to_rgb24},
	    {rgb32_to_bgr24},
	    0,0,0,0,0,
	    {rgb32_to_rgb565},
	    {rgb32_to_rgb555},
	    {rgb32_to_gray},
	    0,0,
	    {rgb32_to_pal8},
	},
	{0},{0},
	{
	    {rgb565_to_yuv420p},
	    0,
	    {rgb565_to_rgb24},
	    0,0,0,
	    {rgb565_to_rgb32},
	    0,0,0,0,
	    {rgb565_to_gray},
	},
	{
	    {rgb555_to_yuv420p},
	    0,
	    {rgb555_to_rgb24},
	    0,0,0,
	    {rgb555_to_rgb32},
	    0,0,0,0,
	    {rgb555_to_gray},
	},
	{
		0,0,
	    {gray_to_rgb24},
	    {gray_to_bgr24},
	    0,0,
	    {gray_to_rgb32},
	    {gray_to_rgb565},
	    {gray_to_rgb555},
	    0,
	    {gray_to_monowhite},
	    {gray_to_monoblack},
	    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	    {gray_to_gray16},
	    {gray_to_gray16},
	},
	{
		0,0,0,0,0,0,0,0,0,0,0,
	    {monowhite_to_gray},
	},
	{
		0,0,0,0,0,0,0,0,0,0,0,
	    {monoblack_to_gray},
	},
	{
		0,0,
	    {pal8_to_rgb24},
	    {pal8_to_bgr24},
	    0,0,
	    {pal8_to_rgb32},
	    0,0,
	    {pal8_to_rgb565},
	    {pal8_to_rgb555},
	},
	{
	    0,0,
	    {yuvj420p_to_rgb24},
	    {yuvj420p_to_bgr24},
	    0,0,
	    {yuvj420p_to_rgb32},
	    0,0,
	    {yuvj420p_to_rgb565},
	    {yuvj420p_to_rgb555},
	},
	{0},
	{
	    0,0,
	    {yuvj444p_to_rgb24},
	},
	{0},{0},
	{
	    {uyvy422_to_yuv420p},
	    {uyvy422_to_yuv422p},
	},
	{
	    0,0,0,0,0,0,0,0,
	    {uyyvyy411_to_yuv411p},
	},
	{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
	{
	    0,0,0,0,0,0,0,0,0,0,0,
	    {gray16be_to_gray},
	    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	    {gray16_to_gray16},
	},
	{
	    0,0,0,0,0,0,0,0,0,0,0,
	    {gray16le_to_gray},
	    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	    {gray16_to_gray16},
	},
#else
    [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] = {