/*
- * Misc image convertion routines
+ * Misc image conversion routines
* Copyright (c) 2001, 2002, 2003 Fabrice Bellard.
*
* This file is part of FFmpeg.
/**
* @file imgconvert.c
- * Misc image convertion routines.
+ * misc image conversion routines
*/
/* TODO:
#include "avcodec.h"
#include "dsputil.h"
-
-#ifdef USE_FASTMEMCPY
-#include "libvo/fastmemcpy.h"
-#endif
+#include "colorspace.h"
#ifdef HAVE_MMX
-#include "i386/mmx.h"
+#include "x86/mmx.h"
+#include "x86/dsputil_mmx.h"
#endif
#define xglue(x, y) x ## y
#define glue(x, y) xglue(x, y)
-#define FF_COLOR_RGB 0 /* RGB color space */
-#define FF_COLOR_GRAY 1 /* gray color space */
-#define FF_COLOR_YUV 2 /* YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
-#define FF_COLOR_YUV_JPEG 3 /* YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
+#define FF_COLOR_RGB 0 /**< RGB color space */
+#define FF_COLOR_GRAY 1 /**< gray color space */
+#define FF_COLOR_YUV 2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
+#define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
-#define FF_PIXEL_PLANAR 0 /* each channel has one component in AVPicture */
-#define FF_PIXEL_PACKED 1 /* only one components containing all the channels */
-#define FF_PIXEL_PALETTE 2 /* one components containing indexes for a palette */
+#define FF_PIXEL_PLANAR 0 /**< each channel has one component in AVPicture */
+#define FF_PIXEL_PACKED 1 /**< only one components containing all the channels */
+#define FF_PIXEL_PALETTE 2 /**< one components containing indexes for a palette */
typedef struct PixFmtInfo {
const char *name;
- uint8_t nb_channels; /* number of channels (including alpha) */
- uint8_t color_type; /* color type (see FF_COLOR_xxx constants) */
- uint8_t pixel_type; /* pixel storage type (see FF_PIXEL_xxx constants) */
- uint8_t is_alpha : 1; /* true if alpha can be specified */
- uint8_t x_chroma_shift; /* X chroma subsampling factor is 2 ^ shift */
- uint8_t y_chroma_shift; /* Y chroma subsampling factor is 2 ^ shift */
- uint8_t depth; /* bit depth of the color components */
+ uint8_t nb_channels; /**< number of channels (including alpha) */
+ uint8_t color_type; /**< color type (see FF_COLOR_xxx constants) */
+ uint8_t pixel_type; /**< pixel storage type (see FF_PIXEL_xxx constants) */
+ uint8_t is_alpha : 1; /**< true if alpha can be specified */
+ uint8_t x_chroma_shift; /**< X chroma subsampling factor is 2 ^ shift */
+ uint8_t y_chroma_shift; /**< Y chroma subsampling factor is 2 ^ shift */
+ uint8_t depth; /**< bit depth of the color components */
} PixFmtInfo;
/* this table gives more information about formats */
.depth = 8,
.x_chroma_shift = 0, .y_chroma_shift = 0,
},
- [PIX_FMT_YUV422] = {
- .name = "yuv422",
+ [PIX_FMT_YUYV422] = {
+ .name = "yuyv422",
.nb_channels = 1,
.color_type = FF_COLOR_YUV,
.pixel_type = FF_PIXEL_PACKED,
.depth = 8,
.x_chroma_shift = 2, .y_chroma_shift = 0,
},
+ [PIX_FMT_YUV440P] = {
+ .name = "yuv440p",
+ .nb_channels = 3,
+ .color_type = FF_COLOR_YUV,
+ .pixel_type = FF_PIXEL_PLANAR,
+ .depth = 8,
+ .x_chroma_shift = 0, .y_chroma_shift = 1,
+ },
+
+ /* YUV formats with alpha plane */
+ [PIX_FMT_YUVA420P] = {
+ .name = "yuva420p",
+ .nb_channels = 4,
+ .color_type = FF_COLOR_YUV,
+ .pixel_type = FF_PIXEL_PLANAR,
+ .depth = 8,
+ .x_chroma_shift = 1, .y_chroma_shift = 1,
+ },
/* JPEG YUV */
[PIX_FMT_YUVJ420P] = {
.depth = 8,
.x_chroma_shift = 0, .y_chroma_shift = 0,
},
+ [PIX_FMT_YUVJ440P] = {
+ .name = "yuvj440p",
+ .nb_channels = 3,
+ .color_type = FF_COLOR_YUV_JPEG,
+ .pixel_type = FF_PIXEL_PLANAR,
+ .depth = 8,
+ .x_chroma_shift = 0, .y_chroma_shift = 1,
+ },
/* RGB formats */
[PIX_FMT_RGB24] = {
.depth = 8,
.x_chroma_shift = 0, .y_chroma_shift = 0,
},
- [PIX_FMT_RGBA32] = {
- .name = "rgba32",
+ [PIX_FMT_RGB32] = {
+ .name = "rgb32",
.nb_channels = 4, .is_alpha = 1,
.color_type = FF_COLOR_RGB,
.pixel_type = FF_PIXEL_PACKED,
[PIX_FMT_XVMC_MPEG2_IDCT] = {
.name = "xvmcidct",
},
- [PIX_FMT_UYVY411] = {
- .name = "uyvy411",
+ [PIX_FMT_UYYVYY411] = {
+ .name = "uyyvyy411",
.nb_channels = 1,
.color_type = FF_COLOR_YUV,
.pixel_type = FF_PIXEL_PACKED,
const char *avcodec_get_pix_fmt_name(int pix_fmt)
{
if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
- return "???";
+ return NULL;
else
return pix_fmt_info[pix_fmt].name;
}
for (i=0; i < PIX_FMT_NB; i++)
if (!strcmp(pix_fmt_info[i].name, name))
- break;
- return i;
+ return i;
+ return PIX_FMT_NONE;
}
-/* Picture field are filled with 'ptr' addresses. Also return size */
-int avpicture_fill(AVPicture *picture, uint8_t *ptr,
- int pix_fmt, int width, int height)
+void avcodec_pix_fmt_string (char *buf, int buf_size, int pix_fmt)
+{
+ /* print header */
+ if (pix_fmt < 0)
+ snprintf (buf, buf_size,
+ "name " " nb_channels" " depth" " is_alpha"
+ );
+ else{
+ PixFmtInfo info= pix_fmt_info[pix_fmt];
+
+ char is_alpha_char= info.is_alpha ? 'y' : 'n';
+
+ snprintf (buf, buf_size,
+ "%-10s" " %1d " " %2d " " %c ",
+ info.name,
+ info.nb_channels,
+ info.depth,
+ is_alpha_char
+ );
+ }
+}
+
+int ff_fill_linesize(AVPicture *picture, int pix_fmt, int width)
{
- int size, w2, h2, size2;
+ int w2;
const PixFmtInfo *pinfo;
- if(avcodec_check_dimensions(NULL, width, height))
- goto fail;
+ memset(picture->linesize, 0, sizeof(picture->linesize));
pinfo = &pix_fmt_info[pix_fmt];
- size = width * height;
switch(pix_fmt) {
case PIX_FMT_YUV420P:
case PIX_FMT_YUV422P:
case PIX_FMT_YUV444P:
case PIX_FMT_YUV410P:
case PIX_FMT_YUV411P:
+ case PIX_FMT_YUV440P:
case PIX_FMT_YUVJ420P:
case PIX_FMT_YUVJ422P:
case PIX_FMT_YUVJ444P:
+ case PIX_FMT_YUVJ440P:
w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
- h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
- size2 = w2 * h2;
- picture->data[0] = ptr;
- picture->data[1] = picture->data[0] + size;
- picture->data[2] = picture->data[1] + size2;
picture->linesize[0] = width;
picture->linesize[1] = w2;
picture->linesize[2] = w2;
- return size + 2 * size2;
+ break;
+ case PIX_FMT_YUVA420P:
+ w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
+ picture->linesize[0] = width;
+ picture->linesize[1] = w2;
+ picture->linesize[2] = w2;
+ picture->linesize[3] = width;
+ break;
case PIX_FMT_NV12:
case PIX_FMT_NV21:
w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
- h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
- size2 = w2 * h2 * 2;
- picture->data[0] = ptr;
- picture->data[1] = picture->data[0] + size;
- picture->data[2] = NULL;
picture->linesize[0] = width;
picture->linesize[1] = w2;
- picture->linesize[2] = 0;
- return size + 2 * size2;
+ break;
case PIX_FMT_RGB24:
case PIX_FMT_BGR24:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
picture->linesize[0] = width * 3;
- return size * 3;
- case PIX_FMT_RGBA32:
+ break;
+ case PIX_FMT_RGB32:
case PIX_FMT_BGR32:
case PIX_FMT_RGB32_1:
case PIX_FMT_BGR32_1:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
picture->linesize[0] = width * 4;
- return size * 4;
+ break;
case PIX_FMT_GRAY16BE:
case PIX_FMT_GRAY16LE:
case PIX_FMT_BGR555:
case PIX_FMT_BGR565:
case PIX_FMT_RGB555:
case PIX_FMT_RGB565:
- case PIX_FMT_YUV422:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
+ case PIX_FMT_YUYV422:
picture->linesize[0] = width * 2;
- return size * 2;
+ break;
case PIX_FMT_UYVY422:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
picture->linesize[0] = width * 2;
- return size * 2;
- case PIX_FMT_UYVY411:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
+ break;
+ case PIX_FMT_UYYVYY411:
picture->linesize[0] = width + width/2;
- return size + size/2;
+ break;
case PIX_FMT_RGB8:
case PIX_FMT_BGR8:
case PIX_FMT_RGB4_BYTE:
case PIX_FMT_BGR4_BYTE:
case PIX_FMT_GRAY8:
- picture->data[0] = ptr;
- picture->data[1] = NULL;
- picture->data[2] = NULL;
picture->linesize[0] = width;
- return size;
+ break;
case PIX_FMT_RGB4:
case PIX_FMT_BGR4:
+ picture->linesize[0] = width / 2;
+ break;
+ case PIX_FMT_MONOWHITE:
+ case PIX_FMT_MONOBLACK:
+ picture->linesize[0] = (width + 7) >> 3;
+ break;
+ case PIX_FMT_PAL8:
+ picture->linesize[0] = width;
+ picture->linesize[1] = 4;
+ break;
+ default:
+ return -1;
+ }
+ return 0;
+}
+
+int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, int pix_fmt,
+ int height)
+{
+ int size, h2, size2;
+ const PixFmtInfo *pinfo;
+
+ pinfo = &pix_fmt_info[pix_fmt];
+ size = picture->linesize[0] * height;
+ switch(pix_fmt) {
+ case PIX_FMT_YUV420P:
+ case PIX_FMT_YUV422P:
+ case PIX_FMT_YUV444P:
+ case PIX_FMT_YUV410P:
+ case PIX_FMT_YUV411P:
+ case PIX_FMT_YUV440P:
+ case PIX_FMT_YUVJ420P:
+ case PIX_FMT_YUVJ422P:
+ case PIX_FMT_YUVJ444P:
+ case PIX_FMT_YUVJ440P:
+ h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
+ size2 = picture->linesize[1] * h2;
picture->data[0] = ptr;
- picture->data[1] = NULL;
+ picture->data[1] = picture->data[0] + size;
+ picture->data[2] = picture->data[1] + size2;
+ picture->data[3] = NULL;
+ return size + 2 * size2;
+ case PIX_FMT_YUVA420P:
+ h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
+ size2 = picture->linesize[1] * h2;
+ picture->data[0] = ptr;
+ picture->data[1] = picture->data[0] + size;
+ picture->data[2] = picture->data[1] + size2;
+ picture->data[3] = picture->data[1] + size2 + size2;
+ return 2 * size + 2 * size2;
+ case PIX_FMT_NV12:
+ case PIX_FMT_NV21:
+ h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
+ size2 = picture->linesize[1] * h2 * 2;
+ picture->data[0] = ptr;
+ picture->data[1] = picture->data[0] + size;
picture->data[2] = NULL;
- picture->linesize[0] = width / 2;
- return size / 2;
+ picture->data[3] = NULL;
+ return size + 2 * size2;
+ case PIX_FMT_RGB24:
+ case PIX_FMT_BGR24:
+ case PIX_FMT_RGB32:
+ case PIX_FMT_BGR32:
+ case PIX_FMT_RGB32_1:
+ case PIX_FMT_BGR32_1:
+ case PIX_FMT_GRAY16BE:
+ case PIX_FMT_GRAY16LE:
+ case PIX_FMT_BGR555:
+ case PIX_FMT_BGR565:
+ case PIX_FMT_RGB555:
+ case PIX_FMT_RGB565:
+ case PIX_FMT_YUYV422:
+ case PIX_FMT_UYVY422:
+ case PIX_FMT_UYYVYY411:
+ case PIX_FMT_RGB8:
+ case PIX_FMT_BGR8:
+ case PIX_FMT_RGB4_BYTE:
+ case PIX_FMT_BGR4_BYTE:
+ case PIX_FMT_GRAY8:
+ case PIX_FMT_RGB4:
+ case PIX_FMT_BGR4:
case PIX_FMT_MONOWHITE:
case PIX_FMT_MONOBLACK:
picture->data[0] = ptr;
picture->data[1] = NULL;
picture->data[2] = NULL;
- picture->linesize[0] = (width + 7) >> 3;
- return picture->linesize[0] * height;
+ picture->data[3] = NULL;
+ return size;
case PIX_FMT_PAL8:
size2 = (size + 3) & ~3;
picture->data[0] = ptr;
picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
picture->data[2] = NULL;
- picture->linesize[0] = width;
- picture->linesize[1] = 4;
+ picture->data[3] = NULL;
return size2 + 256 * 4;
default:
-fail:
picture->data[0] = NULL;
picture->data[1] = NULL;
picture->data[2] = NULL;
}
}
+int avpicture_fill(AVPicture *picture, uint8_t *ptr,
+ int pix_fmt, int width, int height)
+{
+
+ if(avcodec_check_dimensions(NULL, width, height))
+ return -1;
+
+ if (ff_fill_linesize(picture, pix_fmt, width))
+ return -1;
+
+ return ff_fill_pointer(picture, ptr, pix_fmt, height);
+}
+
int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height,
unsigned char *dest, int dest_size)
{
return -1;
if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) {
- if (pix_fmt == PIX_FMT_YUV422 ||
+ if (pix_fmt == PIX_FMT_YUYV422 ||
pix_fmt == PIX_FMT_UYVY422 ||
pix_fmt == PIX_FMT_BGR565 ||
pix_fmt == PIX_FMT_BGR555 ||
pix_fmt == PIX_FMT_RGB565 ||
pix_fmt == PIX_FMT_RGB555)
w = width * 2;
- else if (pix_fmt == PIX_FMT_UYVY411)
+ else if (pix_fmt == PIX_FMT_UYYVYY411)
w = width + width/2;
else if (pix_fmt == PIX_FMT_PAL8)
w = width;
return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
}
-/**
- * compute the loss when converting from a pixel format to another
- */
int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt,
int has_alpha)
{
switch(pf->pixel_type) {
case FF_PIXEL_PACKED:
switch(pix_fmt) {
- case PIX_FMT_YUV422:
+ case PIX_FMT_YUYV422:
case PIX_FMT_UYVY422:
case PIX_FMT_RGB565:
case PIX_FMT_RGB555:
case PIX_FMT_BGR555:
bits = 16;
break;
- case PIX_FMT_UYVY411:
+ case PIX_FMT_UYYVYY411:
bits = 12;
break;
default:
return bits;
}
-static int avcodec_find_best_pix_fmt1(int pix_fmt_mask,
+static int avcodec_find_best_pix_fmt1(int64_t pix_fmt_mask,
int src_pix_fmt,
int has_alpha,
int loss_mask)
dst_pix_fmt = -1;
min_dist = 0x7fffffff;
for(i = 0;i < PIX_FMT_NB; i++) {
- if (pix_fmt_mask & (1 << i)) {
+ if (pix_fmt_mask & (1ULL << i)) {
loss = avcodec_get_pix_fmt_loss(i, src_pix_fmt, has_alpha) & loss_mask;
if (loss == 0) {
dist = avg_bits_per_pixel(i);
return dst_pix_fmt;
}
-/**
- * find best pixel format to convert to. Return -1 if none found
- */
-int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt,
+int avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, int src_pix_fmt,
int has_alpha, int *loss_ptr)
{
int dst_pix_fmt, loss_mask, i;
}
}
-/**
- * Copy image 'src' to 'dst'.
- */
-void img_copy(AVPicture *dst, const AVPicture *src,
- int pix_fmt, int width, int height)
+int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane)
{
- int bwidth, bits, i;
+ int bits;
const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
pf = &pix_fmt_info[pix_fmt];
switch(pf->pixel_type) {
case FF_PIXEL_PACKED:
switch(pix_fmt) {
- case PIX_FMT_YUV422:
+ case PIX_FMT_YUYV422:
case PIX_FMT_UYVY422:
case PIX_FMT_RGB565:
case PIX_FMT_RGB555:
case PIX_FMT_BGR555:
bits = 16;
break;
- case PIX_FMT_UYVY411:
+ case PIX_FMT_UYYVYY411:
bits = 12;
break;
default:
bits = pf->depth * pf->nb_channels;
break;
}
- bwidth = (width * bits + 7) >> 3;
- ff_img_copy_plane(dst->data[0], dst->linesize[0],
- src->data[0], src->linesize[0],
- bwidth, height);
+ return (width * bits + 7) >> 3;
+ break;
+ case FF_PIXEL_PLANAR:
+ if (plane == 1 || plane == 2)
+ width= -((-width)>>pf->x_chroma_shift);
+
+ return (width * pf->depth + 7) >> 3;
break;
+ case FF_PIXEL_PALETTE:
+ if (plane == 0)
+ return width;
+ break;
+ }
+
+ return -1;
+}
+
+void av_picture_copy(AVPicture *dst, const AVPicture *src,
+ int pix_fmt, int width, int height)
+{
+ int i;
+ const PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
+
+ pf = &pix_fmt_info[pix_fmt];
+ switch(pf->pixel_type) {
+ case FF_PIXEL_PACKED:
case FF_PIXEL_PLANAR:
for(i = 0; i < pf->nb_channels; i++) {
- int w, h;
- w = width;
+ int h;
+ int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i);
h = height;
if (i == 1 || i == 2) {
- w >>= pf->x_chroma_shift;
- h >>= pf->y_chroma_shift;
+ h= -((-height)>>pf->y_chroma_shift);
}
- bwidth = (w * pf->depth + 7) >> 3;
ff_img_copy_plane(dst->data[i], dst->linesize[i],
src->data[i], src->linesize[i],
bwidth, h);
/* XXX: totally non optimized */
-static void yuv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
+static void yuyv422_to_yuv420p(AVPicture *dst, const AVPicture *src,
int width, int height)
{
const uint8_t *p, *p1;
}
-static void yuv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
+static void yuyv422_to_yuv422p(AVPicture *dst, const AVPicture *src,
int width, int height)
{
const uint8_t *p, *p1;
}
}
-static void yuv422p_to_yuv422(AVPicture *dst, const AVPicture *src,
+static void yuv422p_to_yuyv422(AVPicture *dst, const AVPicture *src,
int width, int height)
{
uint8_t *p, *p1;
}
}
-static void uyvy411_to_yuv411p(AVPicture *dst, const AVPicture *src,
+static void uyyvyy411_to_yuv411p(AVPicture *dst, const AVPicture *src,
int width, int height)
{
const uint8_t *p, *p1;
}
-static void yuv420p_to_yuv422(AVPicture *dst, const AVPicture *src,
+static void yuv420p_to_yuyv422(AVPicture *dst, const AVPicture *src,
int width, int height)
{
int w, h;
}
}
-#define SCALEBITS 10
-#define ONE_HALF (1 << (SCALEBITS - 1))
-#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
-
-#define YUV_TO_RGB1_CCIR(cb1, cr1)\
-{\
- cb = (cb1) - 128;\
- cr = (cr1) - 128;\
- r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;\
- g_add = - FIX(0.34414*255.0/224.0) * cb - FIX(0.71414*255.0/224.0) * cr + \
- ONE_HALF;\
- b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;\
-}
-
-#define YUV_TO_RGB2_CCIR(r, g, b, y1)\
-{\
- y = ((y1) - 16) * FIX(255.0/219.0);\
- r = cm[(y + r_add) >> SCALEBITS];\
- g = cm[(y + g_add) >> SCALEBITS];\
- b = cm[(y + b_add) >> SCALEBITS];\
-}
-
-#define YUV_TO_RGB1(cb1, cr1)\
-{\
- cb = (cb1) - 128;\
- cr = (cr1) - 128;\
- r_add = FIX(1.40200) * cr + ONE_HALF;\
- g_add = - FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;\
- b_add = FIX(1.77200) * cb + ONE_HALF;\
-}
-
-#define YUV_TO_RGB2(r, g, b, y1)\
-{\
- y = (y1) << SCALEBITS;\
- r = cm[(y + r_add) >> SCALEBITS];\
- g = cm[(y + g_add) >> SCALEBITS];\
- b = cm[(y + b_add) >> SCALEBITS];\
-}
-
-#define Y_CCIR_TO_JPEG(y)\
- cm[((y) * FIX(255.0/219.0) + (ONE_HALF - 16 * FIX(255.0/219.0))) >> SCALEBITS]
-
-#define Y_JPEG_TO_CCIR(y)\
- (((y) * FIX(219.0/255.0) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
-
-#define C_CCIR_TO_JPEG(y)\
- cm[(((y) - 128) * FIX(127.0/112.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS]
-
-/* NOTE: the clamp is really necessary! */
-static inline int C_JPEG_TO_CCIR(int y) {
- y = (((y - 128) * FIX(112.0/127.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS);
- if (y < 16)
- y = 16;
- return y;
-}
-
-
-#define RGB_TO_Y(r, g, b) \
-((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
- FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
-
-#define RGB_TO_U(r1, g1, b1, shift)\
-(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
- FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
-
-#define RGB_TO_V(r1, g1, b1, shift)\
-(((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
- FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
-
-#define RGB_TO_Y_CCIR(r, g, b) \
-((FIX(0.29900*219.0/255.0) * (r) + FIX(0.58700*219.0/255.0) * (g) + \
- FIX(0.11400*219.0/255.0) * (b) + (ONE_HALF + (16 << SCALEBITS))) >> SCALEBITS)
-
-#define RGB_TO_U_CCIR(r1, g1, b1, shift)\
-(((- FIX(0.16874*224.0/255.0) * r1 - FIX(0.33126*224.0/255.0) * g1 + \
- FIX(0.50000*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
-
-#define RGB_TO_V_CCIR(r1, g1, b1, shift)\
-(((FIX(0.50000*224.0/255.0) * r1 - FIX(0.41869*224.0/255.0) * g1 - \
- FIX(0.08131*224.0/255.0) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
-
-static uint8_t y_ccir_to_jpeg[256];
-static uint8_t y_jpeg_to_ccir[256];
-static uint8_t c_ccir_to_jpeg[256];
-static uint8_t c_jpeg_to_ccir[256];
-
-/* init various conversion tables */
-static void img_convert_init(void)
-{
- int i;
- uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
-
- for(i = 0;i < 256; i++) {
- y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
- y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
- c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
- c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
- }
-}
-
-/* apply to each pixel the given table */
-static void img_apply_table(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height, const uint8_t *table1)
+/* 2x2 -> 1x1 */
+void ff_shrink22(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
{
- int n;
- const uint8_t *s;
+ int w;
+ const uint8_t *s1, *s2;
uint8_t *d;
- const uint8_t *table;
- table = table1;
for(;height > 0; height--) {
- s = src;
+ s1 = src;
+ s2 = s1 + src_wrap;
d = dst;
- n = width;
- while (n >= 4) {
- d[0] = table[s[0]];
- d[1] = table[s[1]];
- d[2] = table[s[2]];
- d[3] = table[s[3]];
- d += 4;
- s += 4;
- n -= 4;
- }
- while (n > 0) {
- d[0] = table[s[0]];
- d++;
- s++;
- n--;
- }
- dst += dst_wrap;
- src += src_wrap;
- }
-}
-
-/* XXX: use generic filter ? */
-/* XXX: in most cases, the sampling position is incorrect */
-
-/* 4x1 -> 1x1 */
-static void shrink41(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- int w;
- const uint8_t *s;
- uint8_t *d;
-
- for(;height > 0; height--) {
- s = src;
- d = dst;
- for(w = width;w > 0; w--) {
- d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
- s += 4;
- d++;
- }
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 2x1 -> 1x1 */
-static void shrink21(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- int w;
- const uint8_t *s;
- uint8_t *d;
-
- for(;height > 0; height--) {
- s = src;
- d = dst;
- for(w = width;w > 0; w--) {
- d[0] = (s[0] + s[1]) >> 1;
- s += 2;
- d++;
- }
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 1x2 -> 1x1 */
-static void shrink12(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- int w;
- uint8_t *d;
- const uint8_t *s1, *s2;
-
- for(;height > 0; height--) {
- s1 = src;
- s2 = s1 + src_wrap;
- d = dst;
- for(w = width;w >= 4; w-=4) {
- d[0] = (s1[0] + s2[0]) >> 1;
- d[1] = (s1[1] + s2[1]) >> 1;
- d[2] = (s1[2] + s2[2]) >> 1;
- d[3] = (s1[3] + s2[3]) >> 1;
- s1 += 4;
- s2 += 4;
- d += 4;
- }
- for(;w > 0; w--) {
- d[0] = (s1[0] + s2[0]) >> 1;
- s1++;
- s2++;
- d++;
- }
- src += 2 * src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 2x2 -> 1x1 */
-void ff_shrink22(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- int w;
- const uint8_t *s1, *s2;
- uint8_t *d;
-
- for(;height > 0; height--) {
- s1 = src;
- s2 = s1 + src_wrap;
- d = dst;
- for(w = width;w >= 4; w-=4) {
- d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
- d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
- d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
- d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
- s1 += 8;
- s2 += 8;
+ for(w = width;w >= 4; w-=4) {
+ d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2;
+ d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 2;
+ d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 2;
+ d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 2;
+ s1 += 8;
+ s2 += 8;
d += 4;
}
for(;w > 0; w--) {
}
}
-static void grow21_line(uint8_t *dst, const uint8_t *src,
- int width)
-{
- int w;
- const uint8_t *s1;
- uint8_t *d;
-
- s1 = src;
- d = dst;
- for(w = width;w >= 4; w-=4) {
- d[1] = d[0] = s1[0];
- d[3] = d[2] = s1[1];
- s1 += 2;
- d += 4;
- }
- for(;w >= 2; w -= 2) {
- d[1] = d[0] = s1[0];
- s1 ++;
- d += 2;
- }
- /* only needed if width is not a multiple of two */
- /* XXX: veryfy that */
- if (w) {
- d[0] = s1[0];
- }
-}
-
-static void grow41_line(uint8_t *dst, const uint8_t *src,
- int width)
-{
- int w, v;
- const uint8_t *s1;
- uint8_t *d;
-
- s1 = src;
- d = dst;
- for(w = width;w >= 4; w-=4) {
- v = s1[0];
- d[0] = v;
- d[1] = v;
- d[2] = v;
- d[3] = v;
- s1 ++;
- d += 4;
- }
-}
-
-/* 1x1 -> 2x1 */
-static void grow21(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- for(;height > 0; height--) {
- grow21_line(dst, src, width);
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 1x1 -> 2x2 */
-static void grow22(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- for(;height > 0; height--) {
- grow21_line(dst, src, width);
- if (height%2)
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 1x1 -> 4x1 */
-static void grow41(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- for(;height > 0; height--) {
- grow41_line(dst, src, width);
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 1x1 -> 4x4 */
-static void grow44(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- for(;height > 0; height--) {
- grow41_line(dst, src, width);
- if ((height & 3) == 1)
- src += src_wrap;
- dst += dst_wrap;
- }
-}
-
-/* 1x2 -> 2x1 */
-static void conv411(uint8_t *dst, int dst_wrap,
- const uint8_t *src, int src_wrap,
- int width, int height)
-{
- int w, c;
- const uint8_t *s1, *s2;
- uint8_t *d;
-
- width>>=1;
-
- for(;height > 0; height--) {
- s1 = src;
- s2 = src + src_wrap;
- d = dst;
- for(w = width;w > 0; w--) {
- c = (s1[0] + s2[0]) >> 1;
- d[0] = c;
- d[1] = c;
- s1++;
- s2++;
- d += 2;
- }
- src += src_wrap * 2;
- dst += dst_wrap;
- }
-}
-
/* XXX: add jpeg quantize code */
#define TRANSP_INDEX (6*6*6)
/* this is maybe slow, but allows for extensions */
static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
{
- return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
+ return (((r) / 47) % 6) * 6 * 6 + (((g) / 47) % 6) * 6 + (((b) / 47) % 6);
}
static void build_rgb_palette(uint8_t *palette, int has_alpha)
#define BPP 2
-#include "imgconvert_template.h"
+#include "imgconvert_template.c"
/* rgb565 handling */
#define BPP 2
-#include "imgconvert_template.h"
+#include "imgconvert_template.c"
/* bgr24 handling */
#define BPP 3
-#include "imgconvert_template.h"
+#include "imgconvert_template.c"
#undef RGB_IN
#undef RGB_OUT
#define BPP 3
-#include "imgconvert_template.h"
+#include "imgconvert_template.c"
-/* rgba32 handling */
+/* rgb32 handling */
-#define RGB_NAME rgba32
-#define FMT_RGBA32
+#define RGB_NAME rgb32
+#define FMT_RGB32
#define RGB_IN(r, g, b, s)\
{\
#define BPP 4
-#include "imgconvert_template.h"
+#include "imgconvert_template.c"
static void mono_to_gray(AVPicture *dst, const AVPicture *src,
int width, int height, int xor_mask)
static void gray16le_to_gray(AVPicture *dst, const AVPicture *src,
int width, int height)
{
- gray16_to_gray(dst, src + 1, width, 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 x, y, src_wrap, dst_wrap;
uint16_t *s, *d;
- s = src->data[0];
+ s = (uint16_t*)src->data[0];
src_wrap = (src->linesize[0] - width * 2)/2;
- d = dst->data[0];
+ 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++){
const AVPicture *src, int width, int height);
} ConvertEntry;
-/* Add each new convertion function in this table. In order to be able
+/* 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_GRAY formats must convert to and from PIX_FMT_GRAY8
- - all FF_COLOR_RGB formats with alpha must convert to and from PIX_FMT_RGBA32
+ - 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 optimisations for common cases.
+ 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_YUV422] = {
- .convert = yuv420p_to_yuv422,
+ [PIX_FMT_YUYV422] = {
+ .convert = yuv420p_to_yuyv422,
},
[PIX_FMT_RGB555] = {
.convert = yuv420p_to_rgb555
[PIX_FMT_RGB24] = {
.convert = yuv420p_to_rgb24
},
- [PIX_FMT_RGBA32] = {
- .convert = yuv420p_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = yuv420p_to_rgb32
},
[PIX_FMT_UYVY422] = {
.convert = yuv420p_to_uyvy422,
},
},
[PIX_FMT_YUV422P] = {
- [PIX_FMT_YUV422] = {
- .convert = yuv422p_to_yuv422,
+ [PIX_FMT_YUYV422] = {
+ .convert = yuv422p_to_yuyv422,
},
[PIX_FMT_UYVY422] = {
.convert = yuv422p_to_uyvy422,
[PIX_FMT_RGB24] = {
.convert = yuvj420p_to_rgb24
},
- [PIX_FMT_RGBA32] = {
- .convert = yuvj420p_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = yuvj420p_to_rgb32
},
},
[PIX_FMT_YUVJ444P] = {
.convert = yuvj444p_to_rgb24
},
},
- [PIX_FMT_YUV422] = {
+ [PIX_FMT_YUYV422] = {
[PIX_FMT_YUV420P] = {
- .convert = yuv422_to_yuv420p,
+ .convert = yuyv422_to_yuv420p,
},
[PIX_FMT_YUV422P] = {
- .convert = yuv422_to_yuv422p,
+ .convert = yuyv422_to_yuv422p,
},
},
[PIX_FMT_UYVY422] = {
[PIX_FMT_RGB555] = {
.convert = rgb24_to_rgb555
},
- [PIX_FMT_RGBA32] = {
- .convert = rgb24_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = rgb24_to_rgb32
},
[PIX_FMT_BGR24] = {
.convert = rgb24_to_bgr24
.convert = rgb24_to_yuvj444p
},
},
- [PIX_FMT_RGBA32] = {
+ [PIX_FMT_RGB32] = {
[PIX_FMT_RGB24] = {
- .convert = rgba32_to_rgb24
+ .convert = rgb32_to_rgb24
},
[PIX_FMT_BGR24] = {
- .convert = rgba32_to_bgr24
+ .convert = rgb32_to_bgr24
},
[PIX_FMT_RGB565] = {
- .convert = rgba32_to_rgb565
+ .convert = rgb32_to_rgb565
},
[PIX_FMT_RGB555] = {
- .convert = rgba32_to_rgb555
+ .convert = rgb32_to_rgb555
},
[PIX_FMT_PAL8] = {
- .convert = rgba32_to_pal8
+ .convert = rgb32_to_pal8
},
[PIX_FMT_YUV420P] = {
- .convert = rgba32_to_yuv420p
+ .convert = rgb32_to_yuv420p
},
[PIX_FMT_GRAY8] = {
- .convert = rgba32_to_gray
+ .convert = rgb32_to_gray
},
},
[PIX_FMT_BGR24] = {
- [PIX_FMT_RGBA32] = {
- .convert = bgr24_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = bgr24_to_rgb32
},
[PIX_FMT_RGB24] = {
.convert = bgr24_to_rgb24
[PIX_FMT_RGB24] = {
.convert = rgb555_to_rgb24
},
- [PIX_FMT_RGBA32] = {
- .convert = rgb555_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = rgb555_to_rgb32
},
[PIX_FMT_YUV420P] = {
.convert = rgb555_to_yuv420p
},
},
[PIX_FMT_RGB565] = {
- [PIX_FMT_RGBA32] = {
- .convert = rgb565_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = rgb565_to_rgb32
},
[PIX_FMT_RGB24] = {
.convert = rgb565_to_rgb24
[PIX_FMT_BGR24] = {
.convert = gray_to_bgr24
},
- [PIX_FMT_RGBA32] = {
- .convert = gray_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = gray_to_rgb32
},
[PIX_FMT_MONOWHITE] = {
.convert = gray_to_monowhite
[PIX_FMT_RGB24] = {
.convert = pal8_to_rgb24
},
- [PIX_FMT_RGBA32] = {
- .convert = pal8_to_rgba32
+ [PIX_FMT_RGB32] = {
+ .convert = pal8_to_rgb32
},
},
- [PIX_FMT_UYVY411] = {
+ [PIX_FMT_UYYVYY411] = {
[PIX_FMT_YUV411P] = {
- .convert = uyvy411_to_yuv411p,
+ .convert = uyyvyy411_to_yuv411p,
},
},
ps->pixel_type == FF_PIXEL_PLANAR;
}
-/**
- * Crop image top and left side
- */
-int img_crop(AVPicture *dst, const AVPicture *src,
+int av_picture_crop(AVPicture *dst, const AVPicture *src,
int pix_fmt, int top_band, int left_band)
{
int y_shift;
return 0;
}
-/**
- * Pad image
- */
-int img_pad(AVPicture *dst, const AVPicture *src, int height, int width,
+int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
int pix_fmt, int padtop, int padbottom, int padleft, int padright,
int *color)
{
- uint8_t *optr, *iptr;
+ uint8_t *optr;
int y_shift;
int x_shift;
int yheight;
dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift));
}
- if (padleft || padright || src) {
- if (src) { /* first line */
- iptr = src->data[i];
- optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
- (padleft >> x_shift);
- memcpy(optr, iptr, src->linesize[i]);
- iptr += src->linesize[i];
+ if (padleft || padright) {
+ optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
+ (dst->linesize[i] - (padright >> x_shift));
+ yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
+ for (y = 0; y < yheight; y++) {
+ memset(optr, color[i], (padleft + padright) >> x_shift);
+ optr += dst->linesize[i];
}
+ }
+
+ if (src) { /* first line */
+ uint8_t *iptr = src->data[i];
+ optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
+ (padleft >> x_shift);
+ memcpy(optr, iptr, (width - padleft - padright) >> x_shift);
+ iptr += src->linesize[i];
optr = dst->data[i] + dst->linesize[i] * (padtop >> y_shift) +
(dst->linesize[i] - (padright >> x_shift));
yheight = (height - 1 - (padtop + padbottom)) >> y_shift;
for (y = 0; y < yheight; y++) {
memset(optr, color[i], (padleft + padright) >> x_shift);
- if (src) {
- memcpy(optr + ((padleft + padright) >> x_shift), iptr,
- src->linesize[i]);
- iptr += src->linesize[i];
- }
+ memcpy(optr + ((padleft + padright) >> x_shift), iptr,
+ (width - padleft - padright) >> x_shift);
+ iptr += src->linesize[i];
optr += dst->linesize[i];
}
}
return 0;
}
-#ifndef CONFIG_SWSCALER
-/* XXX: always use linesize. Return -1 if not supported */
+#ifndef CONFIG_SWSCALE
+static uint8_t y_ccir_to_jpeg[256];
+static uint8_t y_jpeg_to_ccir[256];
+static uint8_t c_ccir_to_jpeg[256];
+static uint8_t c_jpeg_to_ccir[256];
+
+/* init various conversion tables */
+static void img_convert_init(void)
+{
+ int i;
+ uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
+
+ for(i = 0;i < 256; i++) {
+ y_ccir_to_jpeg[i] = Y_CCIR_TO_JPEG(i);
+ y_jpeg_to_ccir[i] = Y_JPEG_TO_CCIR(i);
+ c_ccir_to_jpeg[i] = C_CCIR_TO_JPEG(i);
+ c_jpeg_to_ccir[i] = C_JPEG_TO_CCIR(i);
+ }
+}
+
+/* apply to each pixel the given table */
+static void img_apply_table(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height, const uint8_t *table1)
+{
+ int n;
+ const uint8_t *s;
+ uint8_t *d;
+ const uint8_t *table;
+
+ table = table1;
+ for(;height > 0; height--) {
+ s = src;
+ d = dst;
+ n = width;
+ while (n >= 4) {
+ d[0] = table[s[0]];
+ d[1] = table[s[1]];
+ d[2] = table[s[2]];
+ d[3] = table[s[3]];
+ d += 4;
+ s += 4;
+ n -= 4;
+ }
+ while (n > 0) {
+ d[0] = table[s[0]];
+ d++;
+ s++;
+ n--;
+ }
+ dst += dst_wrap;
+ src += src_wrap;
+ }
+}
+
+/* XXX: use generic filter ? */
+/* XXX: in most cases, the sampling position is incorrect */
+
+/* 4x1 -> 1x1 */
+static void shrink41(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ int w;
+ const uint8_t *s;
+ uint8_t *d;
+
+ for(;height > 0; height--) {
+ s = src;
+ d = dst;
+ for(w = width;w > 0; w--) {
+ d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2;
+ s += 4;
+ d++;
+ }
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 2x1 -> 1x1 */
+static void shrink21(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ int w;
+ const uint8_t *s;
+ uint8_t *d;
+
+ for(;height > 0; height--) {
+ s = src;
+ d = dst;
+ for(w = width;w > 0; w--) {
+ d[0] = (s[0] + s[1]) >> 1;
+ s += 2;
+ d++;
+ }
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 1x2 -> 1x1 */
+static void shrink12(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ int w;
+ uint8_t *d;
+ const uint8_t *s1, *s2;
+
+ for(;height > 0; height--) {
+ s1 = src;
+ s2 = s1 + src_wrap;
+ d = dst;
+ for(w = width;w >= 4; w-=4) {
+ d[0] = (s1[0] + s2[0]) >> 1;
+ d[1] = (s1[1] + s2[1]) >> 1;
+ d[2] = (s1[2] + s2[2]) >> 1;
+ d[3] = (s1[3] + s2[3]) >> 1;
+ s1 += 4;
+ s2 += 4;
+ d += 4;
+ }
+ for(;w > 0; w--) {
+ d[0] = (s1[0] + s2[0]) >> 1;
+ s1++;
+ s2++;
+ d++;
+ }
+ src += 2 * src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+static void grow21_line(uint8_t *dst, const uint8_t *src,
+ int width)
+{
+ int w;
+ const uint8_t *s1;
+ uint8_t *d;
+
+ s1 = src;
+ d = dst;
+ for(w = width;w >= 4; w-=4) {
+ d[1] = d[0] = s1[0];
+ d[3] = d[2] = s1[1];
+ s1 += 2;
+ d += 4;
+ }
+ for(;w >= 2; w -= 2) {
+ d[1] = d[0] = s1[0];
+ s1 ++;
+ d += 2;
+ }
+ /* only needed if width is not a multiple of two */
+ /* XXX: veryfy that */
+ if (w) {
+ d[0] = s1[0];
+ }
+}
+
+static void grow41_line(uint8_t *dst, const uint8_t *src,
+ int width)
+{
+ int w, v;
+ const uint8_t *s1;
+ uint8_t *d;
+
+ s1 = src;
+ d = dst;
+ for(w = width;w >= 4; w-=4) {
+ v = s1[0];
+ d[0] = v;
+ d[1] = v;
+ d[2] = v;
+ d[3] = v;
+ s1 ++;
+ d += 4;
+ }
+}
+
+/* 1x1 -> 2x1 */
+static void grow21(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ for(;height > 0; height--) {
+ grow21_line(dst, src, width);
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 1x1 -> 1x2 */
+static void grow12(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ for(;height > 0; height-=2) {
+ memcpy(dst, src, width);
+ dst += dst_wrap;
+ memcpy(dst, src, width);
+ dst += dst_wrap;
+ src += src_wrap;
+ }
+}
+
+/* 1x1 -> 2x2 */
+static void grow22(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ for(;height > 0; height--) {
+ grow21_line(dst, src, width);
+ if (height%2)
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 1x1 -> 4x1 */
+static void grow41(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ for(;height > 0; height--) {
+ grow41_line(dst, src, width);
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 1x1 -> 4x4 */
+static void grow44(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ for(;height > 0; height--) {
+ grow41_line(dst, src, width);
+ if ((height & 3) == 1)
+ src += src_wrap;
+ dst += dst_wrap;
+ }
+}
+
+/* 1x2 -> 2x1 */
+static void conv411(uint8_t *dst, int dst_wrap,
+ const uint8_t *src, int src_wrap,
+ int width, int height)
+{
+ int w, c;
+ const uint8_t *s1, *s2;
+ uint8_t *d;
+
+ width>>=1;
+
+ for(;height > 0; height--) {
+ s1 = src;
+ s2 = src + src_wrap;
+ d = dst;
+ for(w = width;w > 0; w--) {
+ c = (s1[0] + s2[0]) >> 1;
+ d[0] = c;
+ d[1] = c;
+ s1++;
+ s2++;
+ d += 2;
+ }
+ src += src_wrap * 2;
+ dst += dst_wrap;
+ }
+}
+
+/* XXX: always use linesize. Return -1 if not supported */
int img_convert(AVPicture *dst, int dst_pix_fmt,
const AVPicture *src, int src_pix_fmt,
int src_width, int src_height)
{
- static int inited;
+ static int initialized;
int i, ret, dst_width, dst_height, int_pix_fmt;
const PixFmtInfo *src_pix, *dst_pix;
const ConvertEntry *ce;
if (src_width <= 0 || src_height <= 0)
return 0;
- if (!inited) {
- inited = 1;
+ if (!initialized) {
+ initialized = 1;
img_convert_init();
}
src_pix = &pix_fmt_info[src_pix_fmt];
if (src_pix_fmt == dst_pix_fmt) {
/* no conversion needed: just copy */
- img_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
+ av_picture_copy(dst, src, dst_pix_fmt, dst_width, dst_height);
return 0;
}
case 0xf0:
resize_func = grow21;
break;
+ case 0x0f:
+ resize_func = grow12;
+ break;
case 0xe0:
resize_func = grow41;
break;
no_chroma_filter:
/* try to use an intermediate format */
- if (src_pix_fmt == PIX_FMT_YUV422 ||
- dst_pix_fmt == PIX_FMT_YUV422) {
+ if (src_pix_fmt == PIX_FMT_YUYV422 ||
+ dst_pix_fmt == PIX_FMT_YUYV422) {
/* specific case: convert to YUV422P first */
int_pix_fmt = PIX_FMT_YUV422P;
} else if (src_pix_fmt == PIX_FMT_UYVY422 ||
dst_pix_fmt == PIX_FMT_UYVY422) {
/* specific case: convert to YUV422P first */
int_pix_fmt = PIX_FMT_YUV422P;
- } else if (src_pix_fmt == PIX_FMT_UYVY411 ||
- dst_pix_fmt == PIX_FMT_UYVY411) {
+ } else if (src_pix_fmt == PIX_FMT_UYYVYY411 ||
+ dst_pix_fmt == PIX_FMT_UYYVYY411) {
/* specific case: convert to YUV411P first */
int_pix_fmt = PIX_FMT_YUV411P;
} else if ((src_pix->color_type == FF_COLOR_GRAY &&
} else {
/* the two formats are rgb or gray8 or yuv[j]444p */
if (src_pix->is_alpha && dst_pix->is_alpha)
- int_pix_fmt = PIX_FMT_RGBA32;
+ int_pix_fmt = PIX_FMT_RGB32;
else
int_pix_fmt = PIX_FMT_RGB24;
}
+ if (src_pix_fmt == int_pix_fmt)
+ return -1;
if (avpicture_alloc(tmp, int_pix_fmt, dst_width, dst_height) < 0)
return -1;
ret = -1;
return ret;
}
-/**
- * Tell if an image really has transparent alpha values.
- * @return ored mask of FF_ALPHA_xxx constants
- */
int img_get_alpha_info(const AVPicture *src,
int pix_fmt, int width, int height)
{
if (!pf->is_alpha)
return 0;
switch(pix_fmt) {
- case PIX_FMT_RGBA32:
- ret = get_alpha_info_rgba32(src, width, height);
+ case PIX_FMT_RGB32:
+ ret = get_alpha_info_rgb32(src, width, height);
break;
case PIX_FMT_PAL8:
ret = get_alpha_info_pal8(src, width, height);
#else
{
- mmx_t rounder;
- rounder.uw[0]=4;
- rounder.uw[1]=4;
- rounder.uw[2]=4;
- rounder.uw[3]=4;
pxor_r2r(mm7,mm7);
- movq_m2r(rounder,mm6);
+ movq_m2r(ff_pw_4,mm6);
}
for (;size > 3; size-=4) {
DEINT_LINE_LUM
#else
{
- mmx_t rounder;
- rounder.uw[0]=4;
- rounder.uw[1]=4;
- rounder.uw[2]=4;
- rounder.uw[3]=4;
pxor_r2r(mm7,mm7);
- movq_m2r(rounder,mm6);
+ movq_m2r(ff_pw_4,mm6);
}
for (;size > 3; size-=4) {
DEINT_INPLACE_LINE_LUM
av_free(buf);
}
-
-/* deinterlace - if not supported return -1 */
int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
int pix_fmt, int width, int height)
{
if (pix_fmt != PIX_FMT_YUV420P &&
pix_fmt != PIX_FMT_YUV422P &&
pix_fmt != PIX_FMT_YUV444P &&
- pix_fmt != PIX_FMT_YUV411P)
+ pix_fmt != PIX_FMT_YUV411P &&
+ pix_fmt != PIX_FMT_GRAY8)
return -1;
if ((width & 3) != 0 || (height & 3) != 0)
return -1;
default:
break;
}
+ if (pix_fmt == PIX_FMT_GRAY8) {
+ break;
+ }
}
if (src == dst) {
deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i],
width, height);
}
}
-#ifdef HAVE_MMX
- emms();
-#endif
+ emms_c();
return 0;
}
-#undef FIX
projects / ffmpeg / blobdiff