X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fimgconvert.c;h=17c8473c3ad9824b4b5e4071350a234bb8f814b5;hb=a44cb89b0f53d55dd1814138ba6526ecaf985f12;hp=6c0128ca9d41a71fa3e1887d518ea56688256c1f;hpb=e352ff0895df85594dd8df385a650d45b74a28e3;p=ffmpeg diff --git a/libavcodec/imgconvert.c b/libavcodec/imgconvert.c index 6c0128ca9d4..17c8473c3ad 100644 --- a/libavcodec/imgconvert.c +++ b/libavcodec/imgconvert.c @@ -1,25 +1,27 @@ /* - * Misc image convertion routines - * Copyright (c) 2001, 2002, 2003 Fabrice Bellard. + * Misc image conversion routines + * Copyright (c) 2001, 2002, 2003 Fabrice Bellard * - * This library is free software; you can redistribute it and/or + * This file is part of FFmpeg. + * + * FFmpeg 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. + * version 2.1 of the License, or (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * FFmpeg 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 + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** * @file imgconvert.c - * Misc image convertion routines. + * misc image conversion routines */ /* TODO: @@ -30,40 +32,38 @@ #include "avcodec.h" #include "dsputil.h" +#include "colorspace.h" -#ifdef USE_FASTMEMCPY -#include "fastmemcpy.h" -#endif - -#ifdef HAVE_MMX -#include "i386/mmx.h" +#if HAVE_MMX +#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 */ -static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { +static const PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { /* YUV formats */ [PIX_FMT_YUV420P] = { .name = "yuv420p", @@ -71,7 +71,7 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 1, .y_chroma_shift = 1, + .x_chroma_shift = 1, .y_chroma_shift = 1, }, [PIX_FMT_YUV422P] = { .name = "yuv422p", @@ -79,7 +79,7 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 1, .y_chroma_shift = 0, + .x_chroma_shift = 1, .y_chroma_shift = 0, }, [PIX_FMT_YUV444P] = { .name = "yuv444p", @@ -87,10 +87,18 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 0, .y_chroma_shift = 0, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_YUYV422] = { + .name = "yuyv422", + .nb_channels = 1, + .color_type = FF_COLOR_YUV, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 1, .y_chroma_shift = 0, }, - [PIX_FMT_YUV422] = { - .name = "yuv422", + [PIX_FMT_UYVY422] = { + .name = "uyvy422", .nb_channels = 1, .color_type = FF_COLOR_YUV, .pixel_type = FF_PIXEL_PACKED, @@ -113,6 +121,24 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .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] = { @@ -121,7 +147,7 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV_JPEG, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 1, .y_chroma_shift = 1, + .x_chroma_shift = 1, .y_chroma_shift = 1, }, [PIX_FMT_YUVJ422P] = { .name = "yuvj422p", @@ -129,7 +155,7 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV_JPEG, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 1, .y_chroma_shift = 0, + .x_chroma_shift = 1, .y_chroma_shift = 0, }, [PIX_FMT_YUVJ444P] = { .name = "yuvj444p", @@ -137,7 +163,15 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_YUV_JPEG, .pixel_type = FF_PIXEL_PLANAR, .depth = 8, - .x_chroma_shift = 0, .y_chroma_shift = 0, + .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 */ @@ -147,6 +181,7 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_RGB, .pixel_type = FF_PIXEL_PACKED, .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, }, [PIX_FMT_BGR24] = { .name = "bgr24", @@ -154,13 +189,15 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_RGB, .pixel_type = FF_PIXEL_PACKED, .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, .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, }, [PIX_FMT_RGB565] = { .name = "rgb565", @@ -168,16 +205,32 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .color_type = FF_COLOR_RGB, .pixel_type = FF_PIXEL_PACKED, .depth = 5, + .x_chroma_shift = 0, .y_chroma_shift = 0, }, [PIX_FMT_RGB555] = { .name = "rgb555", - .nb_channels = 4, .is_alpha = 1, + .nb_channels = 3, .color_type = FF_COLOR_RGB, .pixel_type = FF_PIXEL_PACKED, .depth = 5, + .x_chroma_shift = 0, .y_chroma_shift = 0, }, /* gray / mono formats */ + [PIX_FMT_GRAY16BE] = { + .name = "gray16be", + .nb_channels = 1, + .color_type = FF_COLOR_GRAY, + .pixel_type = FF_PIXEL_PLANAR, + .depth = 16, + }, + [PIX_FMT_GRAY16LE] = { + .name = "gray16le", + .nb_channels = 1, + .color_type = FF_COLOR_GRAY, + .pixel_type = FF_PIXEL_PLANAR, + .depth = 16, + }, [PIX_FMT_GRAY8] = { .name = "gray", .nb_channels = 1, @@ -208,6 +261,140 @@ static PixFmtInfo pix_fmt_info[PIX_FMT_NB] = { .pixel_type = FF_PIXEL_PALETTE, .depth = 8, }, + [PIX_FMT_XVMC_MPEG2_MC] = { + .name = "xvmcmc", + }, + [PIX_FMT_XVMC_MPEG2_IDCT] = { + .name = "xvmcidct", + }, + [PIX_FMT_VDPAU_MPEG1] = { + .name = "vdpau_mpeg1", + }, + [PIX_FMT_VDPAU_MPEG2] = { + .name = "vdpau_mpeg2", + }, + [PIX_FMT_VDPAU_H264] = { + .name = "vdpau_h264", + }, + [PIX_FMT_VDPAU_WMV3] = { + .name = "vdpau_wmv3", + }, + [PIX_FMT_VDPAU_VC1] = { + .name = "vdpau_vc1", + }, + [PIX_FMT_UYYVYY411] = { + .name = "uyyvyy411", + .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_BGR32] = { + .name = "bgr32", + .nb_channels = 4, .is_alpha = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_BGR565] = { + .name = "bgr565", + .nb_channels = 3, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 5, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_BGR555] = { + .name = "bgr555", + .nb_channels = 3, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 5, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_RGB8] = { + .name = "rgb8", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_RGB4] = { + .name = "rgb4", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 4, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_RGB4_BYTE] = { + .name = "rgb4_byte", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_BGR8] = { + .name = "bgr8", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_BGR4] = { + .name = "bgr4", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 4, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_BGR4_BYTE] = { + .name = "bgr4_byte", + .nb_channels = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_NV12] = { + .name = "nv12", + .nb_channels = 2, + .color_type = FF_COLOR_YUV, + .pixel_type = FF_PIXEL_PLANAR, + .depth = 8, + .x_chroma_shift = 1, .y_chroma_shift = 1, + }, + [PIX_FMT_NV21] = { + .name = "nv12", + .nb_channels = 2, + .color_type = FF_COLOR_YUV, + .pixel_type = FF_PIXEL_PLANAR, + .depth = 8, + .x_chroma_shift = 1, .y_chroma_shift = 1, + }, + + [PIX_FMT_BGR32_1] = { + .name = "bgr32_1", + .nb_channels = 4, .is_alpha = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, + [PIX_FMT_RGB32_1] = { + .name = "rgb32_1", + .nb_channels = 4, .is_alpha = 1, + .color_type = FF_COLOR_RGB, + .pixel_type = FF_PIXEL_PACKED, + .depth = 8, + .x_chroma_shift = 0, .y_chroma_shift = 0, + }, }; void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift) @@ -219,80 +406,208 @@ void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift) 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; } -/* 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) +enum PixelFormat avcodec_get_pix_fmt(const char* name) +{ + int i; + + for (i=0; i < PIX_FMT_NB; i++) + if (!strcmp(pix_fmt_info[i].name, name)) + return i; + return PIX_FMT_NONE; +} + +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; - PixFmtInfo *pinfo; - + int w2; + const PixFmtInfo *pinfo; + + 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; + picture->linesize[0] = width; + picture->linesize[1] = w2; + 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: - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; + break; + case PIX_FMT_RGB32: + case PIX_FMT_BGR32: + case PIX_FMT_RGB32_1: + case PIX_FMT_BGR32_1: 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; + break; + case PIX_FMT_UYVY422: picture->linesize[0] = width * 2; - return size * 2; + break; + case PIX_FMT_UYYVYY411: + picture->linesize[0] = width + width/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->linesize[0] = width; + 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; - return size; + 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: picture->data[0] = NULL; @@ -303,15 +618,78 @@ int avpicture_fill(AVPicture *picture, uint8_t *ptr, } } +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) +{ + const PixFmtInfo* pf = &pix_fmt_info[pix_fmt]; + int i, j, w, h, data_planes; + const unsigned char* s; + int size = avpicture_get_size(pix_fmt, width, height); + + if (size > dest_size || size < 0) + return -1; + + if (pf->pixel_type == FF_PIXEL_PACKED || pf->pixel_type == FF_PIXEL_PALETTE) { + 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_UYYVYY411) + w = width + width/2; + else if (pix_fmt == PIX_FMT_PAL8) + w = width; + else + w = width * (pf->depth * pf->nb_channels / 8); + + data_planes = 1; + h = height; + } else { + data_planes = pf->nb_channels; + w = (width*pf->depth + 7)/8; + h = height; + } + + for (i=0; i> pf->x_chroma_shift; + h = height >> pf->y_chroma_shift; + } + s = src->data[i]; + for(j=0; jlinesize[i]; + } + } + + if (pf->pixel_type == FF_PIXEL_PALETTE) + memcpy((unsigned char *)(((size_t)dest + 3) & ~3), src->data[1], 256 * 4); + + return size; +} + int avpicture_get_size(int pix_fmt, int width, int height) { AVPicture dummy_pict; 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) { @@ -324,10 +702,11 @@ int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, /* compute loss */ loss = 0; pf = &pix_fmt_info[dst_pix_fmt]; - if (pf->depth < ps->depth) + if (pf->depth < ps->depth || + (dst_pix_fmt == PIX_FMT_RGB555 && src_pix_fmt == PIX_FMT_RGB565)) loss |= FF_LOSS_DEPTH; - if (pf->x_chroma_shift >= ps->x_chroma_shift || - pf->y_chroma_shift >= ps->y_chroma_shift) + if (pf->x_chroma_shift > ps->x_chroma_shift || + pf->y_chroma_shift > ps->y_chroma_shift) loss |= FF_LOSS_RESOLUTION; switch(pf->color_type) { case FF_COLOR_RGB: @@ -345,7 +724,8 @@ int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, break; case FF_COLOR_YUV_JPEG: if (ps->color_type != FF_COLOR_YUV_JPEG && - ps->color_type != FF_COLOR_YUV) + ps->color_type != FF_COLOR_YUV && + ps->color_type != FF_COLOR_GRAY) loss |= FF_LOSS_COLORSPACE; break; default: @@ -359,7 +739,7 @@ int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, loss |= FF_LOSS_CHROMA; if (!pf->is_alpha && (ps->is_alpha && has_alpha)) loss |= FF_LOSS_ALPHA; - if (pf->pixel_type == FF_PIXEL_PALETTE && + if (pf->pixel_type == FF_PIXEL_PALETTE && (ps->pixel_type != FF_PIXEL_PALETTE && ps->color_type != FF_COLOR_GRAY)) loss |= FF_LOSS_COLORQUANT; return loss; @@ -374,11 +754,17 @@ static int avg_bits_per_pixel(int 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_BGR565: + case PIX_FMT_BGR555: bits = 16; break; + case PIX_FMT_UYYVYY411: + bits = 12; + break; default: bits = pf->depth * pf->nb_channels; break; @@ -388,7 +774,7 @@ static int avg_bits_per_pixel(int pix_fmt) if (pf->x_chroma_shift == 0 && pf->y_chroma_shift == 0) { bits = pf->depth * pf->nb_channels; } else { - bits = pf->depth + ((2 * pf->depth) >> + bits = pf->depth + ((2 * pf->depth) >> (pf->x_chroma_shift + pf->y_chroma_shift)); } break; @@ -402,7 +788,7 @@ static int avg_bits_per_pixel(int pix_fmt) 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) @@ -413,7 +799,7 @@ static int avcodec_find_best_pix_fmt1(int pix_fmt_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); @@ -427,10 +813,7 @@ static int avcodec_find_best_pix_fmt1(int pix_fmt_mask, 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; @@ -448,7 +831,7 @@ int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt, i = 0; for(;;) { loss_mask = loss_mask_order[i++]; - dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt, + dst_pix_fmt = avcodec_find_best_pix_fmt1(pix_fmt_mask, src_pix_fmt, has_alpha, loss_mask); if (dst_pix_fmt >= 0) goto found; @@ -462,10 +845,12 @@ int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt, return dst_pix_fmt; } -static void img_copy_plane(uint8_t *dst, int dst_wrap, +void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height) { + if((!dst) || (!src)) + return; for(;height > 0; height--) { memcpy(dst, src, width); dst += dst_wrap; @@ -473,52 +858,75 @@ static void img_copy_plane(uint8_t *dst, int dst_wrap, } } -/* copy image 'src' to 'dst' */ -void img_copy(AVPicture *dst, 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; - PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; - + 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_BGR565: + case PIX_FMT_BGR555: bits = 16; break; + case PIX_FMT_UYYVYY411: + bits = 12; + break; default: bits = pf->depth * pf->nb_channels; break; } - bwidth = (width * bits + 7) >> 3; - 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: - for(i = 0; i < pf->nb_channels; i++) { - int w, h; - w = width; - h = height; - if (i == 1 || i == 2) { - w >>= pf->x_chroma_shift; - h >>= pf->y_chroma_shift; - } - bwidth = (w * pf->depth + 7) >> 3; - img_copy_plane(dst->data[i], dst->linesize[i], - src->data[i], src->linesize[i], - bwidth, h); - } + if (plane == 1 || plane == 2) + width= -((-width)>>pf->x_chroma_shift); + + return (width * pf->depth + 7) >> 3; break; case FF_PIXEL_PALETTE: - img_copy_plane(dst->data[0], dst->linesize[0], - src->data[0], src->linesize[0], - width, height); - /* copy the palette */ - img_copy_plane(dst->data[1], dst->linesize[1], + 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 h; + int bwidth = ff_get_plane_bytewidth(pix_fmt, width, i); + h = height; + if (i == 1 || i == 2) { + h= -((-height)>>pf->y_chroma_shift); + } + ff_img_copy_plane(dst->data[i], dst->linesize[i], + src->data[i], src->linesize[i], + bwidth, h); + } + break; + case FF_PIXEL_PALETTE: + ff_img_copy_plane(dst->data[0], dst->linesize[0], + src->data[0], src->linesize[0], + width, height); + /* copy the palette */ + ff_img_copy_plane(dst->data[1], dst->linesize[1], src->data[1], src->linesize[1], 4, 256); break; @@ -527,24 +935,24 @@ void img_copy(AVPicture *dst, AVPicture *src, /* XXX: totally non optimized */ -static void yuv422_to_yuv420p(AVPicture *dst, AVPicture *src, +static void yuyv422_to_yuv420p(AVPicture *dst, const AVPicture *src, int width, int height) { const uint8_t *p, *p1; uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; - int x; - + int w; + p1 = src->data[0]; lum1 = dst->data[0]; - cb1 = dst->data[0]; - cr1 = dst->data[0]; + cb1 = dst->data[1]; + cr1 = dst->data[2]; - for(;height >= 2; height -= 2) { + for(;height >= 1; height -= 2) { p = p1; lum = lum1; cb = cb1; cr = cr1; - for(x=0;x= 2; w -= 2) { lum[0] = p[0]; cb[0] = p[1]; lum[1] = p[2]; @@ -554,15 +962,118 @@ static void yuv422_to_yuv420p(AVPicture *dst, AVPicture *src, cb++; cr++; } + if (w) { + lum[0] = p[0]; + cb[0] = p[1]; + cr[0] = p[3]; + cb++; + cr++; + } p1 += src->linesize[0]; lum1 += dst->linesize[0]; + if (height>1) { + p = p1; + lum = lum1; + for(w = width; w >= 2; w -= 2) { + lum[0] = p[0]; + lum[1] = p[2]; + p += 4; + lum += 2; + } + if (w) { + lum[0] = p[0]; + } + p1 += src->linesize[0]; + lum1 += dst->linesize[0]; + } + cb1 += dst->linesize[1]; + cr1 += dst->linesize[2]; + } +} + +static void uyvy422_to_yuv420p(AVPicture *dst, const AVPicture *src, + int width, int height) +{ + const uint8_t *p, *p1; + uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; + int w; + + p1 = src->data[0]; + + lum1 = dst->data[0]; + cb1 = dst->data[1]; + cr1 = dst->data[2]; + + for(;height >= 1; height -= 2) { p = p1; lum = lum1; - for(x=0;x= 2; w -= 2) { + lum[0] = p[1]; + cb[0] = p[0]; + lum[1] = p[3]; + cr[0] = p[2]; + p += 4; + lum += 2; + cb++; + cr++; + } + if (w) { + lum[0] = p[1]; + cb[0] = p[0]; + cr[0] = p[2]; + cb++; + cr++; + } + p1 += src->linesize[0]; + lum1 += dst->linesize[0]; + if (height>1) { + p = p1; + lum = lum1; + for(w = width; w >= 2; w -= 2) { + lum[0] = p[1]; + lum[1] = p[3]; + p += 4; + lum += 2; + } + if (w) { + lum[0] = p[1]; + } + p1 += src->linesize[0]; + lum1 += dst->linesize[0]; + } + cb1 += dst->linesize[1]; + cr1 += dst->linesize[2]; + } +} + + +static void uyvy422_to_yuv422p(AVPicture *dst, const AVPicture *src, + int width, int height) +{ + const uint8_t *p, *p1; + uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; + int w; + + p1 = src->data[0]; + lum1 = dst->data[0]; + cb1 = dst->data[1]; + cr1 = dst->data[2]; + for(;height > 0; height--) { + p = p1; + lum = lum1; + cb = cb1; + cr = cr1; + for(w = width; w >= 2; w -= 2) { + lum[0] = p[1]; + cb[0] = p[0]; + lum[1] = p[3]; + cr[0] = p[2]; p += 4; lum += 2; + cb++; + cr++; } p1 += src->linesize[0]; lum1 += dst->linesize[0]; @@ -571,7 +1082,8 @@ static void yuv422_to_yuv420p(AVPicture *dst, AVPicture *src, } } -static void yuv422_to_yuv422p(AVPicture *dst, AVPicture *src, + +static void yuyv422_to_yuv422p(AVPicture *dst, const AVPicture *src, int width, int height) { const uint8_t *p, *p1; @@ -580,9 +1092,9 @@ static void yuv422_to_yuv422p(AVPicture *dst, AVPicture *src, p1 = src->data[0]; lum1 = dst->data[0]; - cb1 = dst->data[0]; - cr1 = dst->data[0]; - for(;height >= 2; height -= 2) { + cb1 = dst->data[1]; + cr1 = dst->data[2]; + for(;height > 0; height--) { p = p1; lum = lum1; cb = cb1; @@ -604,7 +1116,7 @@ static void yuv422_to_yuv422p(AVPicture *dst, AVPicture *src, } } -static void yuv422p_to_yuv422(AVPicture *dst, AVPicture *src, +static void yuv422p_to_yuyv422(AVPicture *dst, const AVPicture *src, int width, int height) { uint8_t *p, *p1; @@ -613,9 +1125,9 @@ static void yuv422p_to_yuv422(AVPicture *dst, AVPicture *src, p1 = dst->data[0]; lum1 = src->data[0]; - cb1 = src->data[0]; - cr1 = src->data[0]; - for(;height >= 2; height -= 2) { + cb1 = src->data[1]; + cr1 = src->data[2]; + for(;height > 0; height--) { p = p1; lum = lum1; cb = cb1; @@ -630,426 +1142,242 @@ static void yuv422p_to_yuv422(AVPicture *dst, AVPicture *src, cb++; cr++; } - p1 += src->linesize[0]; - lum1 += dst->linesize[0]; - cb1 += dst->linesize[1]; - cr1 += dst->linesize[2]; + p1 += dst->linesize[0]; + lum1 += src->linesize[0]; + cb1 += src->linesize[1]; + cr1 += src->linesize[2]; } } -#define SCALEBITS 10 -#define ONE_HALF (1 << (SCALEBITS - 1)) -#define FIX(x) ((int) ((x) * (1<> SCALEBITS];\ - g = cm[(y + g_add) >> SCALEBITS];\ - b = cm[(y + b_add) >> SCALEBITS];\ + p1 = dst->data[0]; + lum1 = src->data[0]; + cb1 = src->data[1]; + cr1 = src->data[2]; + for(;height > 0; height--) { + p = p1; + lum = lum1; + cb = cb1; + cr = cr1; + for(w = width; w >= 2; w -= 2) { + p[1] = lum[0]; + p[0] = cb[0]; + p[3] = lum[1]; + p[2] = cr[0]; + p += 4; + lum += 2; + cb++; + cr++; + } + p1 += dst->linesize[0]; + lum1 += src->linesize[0]; + cb1 += src->linesize[1]; + cr1 += src->linesize[2]; + } } -#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;\ -} +static void uyyvyy411_to_yuv411p(AVPicture *dst, const AVPicture *src, + int width, int height) +{ + const uint8_t *p, *p1; + uint8_t *lum, *cr, *cb, *lum1, *cr1, *cb1; + int w; -#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];\ + p1 = src->data[0]; + lum1 = dst->data[0]; + cb1 = dst->data[1]; + cr1 = dst->data[2]; + for(;height > 0; height--) { + p = p1; + lum = lum1; + cb = cb1; + cr = cr1; + for(w = width; w >= 4; w -= 4) { + cb[0] = p[0]; + lum[0] = p[1]; + lum[1] = p[2]; + cr[0] = p[3]; + lum[2] = p[4]; + lum[3] = p[5]; + p += 6; + lum += 4; + cb++; + cr++; + } + p1 += src->linesize[0]; + lum1 += dst->linesize[0]; + cb1 += dst->linesize[1]; + cr1 += dst->linesize[2]; + } } -#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! */ -#define C_JPEG_TO_CCIR(y)\ -({\ - int __y;\ - __y = ((((y) - 128) * FIX(112.0/127.0) + (ONE_HALF + (128 << SCALEBITS))) >> SCALEBITS);\ - if (__y < 16)\ - __y = 16;\ - __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 void yuv420p_to_yuyv422(AVPicture *dst, const AVPicture *src, + int width, int height) +{ + int w, h; + uint8_t *line1, *line2, *linesrc = dst->data[0]; + uint8_t *lum1, *lum2, *lumsrc = src->data[0]; + uint8_t *cb1, *cb2 = src->data[1]; + uint8_t *cr1, *cr2 = src->data[2]; + + for(h = height / 2; h--;) { + line1 = linesrc; + line2 = linesrc + dst->linesize[0]; + + lum1 = lumsrc; + lum2 = lumsrc + src->linesize[0]; + + cb1 = cb2; + cr1 = cr2; + + for(w = width / 2; w--;) { + *line1++ = *lum1++; *line2++ = *lum2++; + *line1++ = *line2++ = *cb1++; + *line1++ = *lum1++; *line2++ = *lum2++; + *line1++ = *line2++ = *cr1++; + } -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]; + linesrc += dst->linesize[0] * 2; + lumsrc += src->linesize[0] * 2; + cb2 += src->linesize[1]; + cr2 += src->linesize[2]; + } +} -/* init various conversion tables */ -static void img_convert_init(void) +static void yuv420p_to_uyvy422(AVPicture *dst, const AVPicture *src, + int width, int height) { - int i; - uint8_t *cm = cropTbl + MAX_NEG_CROP; + int w, h; + uint8_t *line1, *line2, *linesrc = dst->data[0]; + uint8_t *lum1, *lum2, *lumsrc = src->data[0]; + uint8_t *cb1, *cb2 = src->data[1]; + uint8_t *cr1, *cr2 = src->data[2]; + + for(h = height / 2; h--;) { + line1 = linesrc; + line2 = linesrc + dst->linesize[0]; + + lum1 = lumsrc; + lum2 = lumsrc + src->linesize[0]; + + cb1 = cb2; + cr1 = cr2; + + for(w = width / 2; w--;) { + *line1++ = *line2++ = *cb1++; + *line1++ = *lum1++; *line2++ = *lum2++; + *line1++ = *line2++ = *cr1++; + *line1++ = *lum1++; *line2++ = *lum2++; + } - 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); + linesrc += dst->linesize[0] * 2; + lumsrc += src->linesize[0] * 2; + cb2 += src->linesize[1]; + cr2 += src->linesize[2]; } } -/* 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]]; + 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; - s += 4; - n -= 4; } - while (n > 0) { - d[0] = table[s[0]]; + for(;w > 0; w--) { + d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 2; + s1 += 2; + s2 += 2; d++; - s++; - n--; } + src += 2 * src_wrap; 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, +/* 4x4 -> 1x1 */ +void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height) { int w; - const uint8_t *s; + const uint8_t *s1, *s2, *s3, *s4; uint8_t *d; for(;height > 0; height--) { - s = src; + s1 = src; + s2 = s1 + src_wrap; + s3 = s2 + src_wrap; + s4 = s3 + src_wrap; d = dst; for(w = width;w > 0; w--) { - d[0] = (s[0] + s[1] + s[2] + s[3] + 2) >> 2; - s += 4; + d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + + s2[0] + s2[1] + s2[2] + s2[3] + + s3[0] + s3[1] + s3[2] + s3[3] + + s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; + s1 += 4; + s2 += 4; + s3 += 4; + s4 += 4; d++; } - src += src_wrap; + src += 4 * src_wrap; dst += dst_wrap; } } -/* 2x1 -> 1x1 */ -static void shrink21(uint8_t *dst, int dst_wrap, +/* 8x8 -> 1x1 */ +void ff_shrink88(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; + int w, i; for(;height > 0; height--) { - s = src; - d = dst; for(w = width;w > 0; w--) { - d[0] = (s[0] + s[1]) >> 1; - s += 2; - d++; + int tmp=0; + for(i=0; i<8; i++){ + tmp += src[0] + src[1] + src[2] + src[3] + src[4] + src[5] + src[6] + src[7]; + src += src_wrap; + } + *(dst++) = (tmp + 32)>>6; + src += 8 - 8*src_wrap; } - src += src_wrap; - dst += dst_wrap; + src += 8*src_wrap - 8*width; + dst += dst_wrap - width; } } -/* 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 */ -static void 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) >> 1; - d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 1; - d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 1; - d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 1; - s1 += 8; - s2 += 8; - d += 4; - } - for(;w > 0; w--) { - d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 1; - s1 += 2; - s2 += 2; - d++; - } - src += 2 * src_wrap; - dst += dst_wrap; - } -} - -/* 4x4 -> 1x1 */ -static void shrink44(uint8_t *dst, int dst_wrap, - const uint8_t *src, int src_wrap, - int width, int height) -{ - int w; - const uint8_t *s1, *s2, *s3, *s4; - uint8_t *d; - - for(;height > 0; height--) { - s1 = src; - s2 = s1 + src_wrap; - s3 = s2 + src_wrap; - s4 = s3 + src_wrap; - d = dst; - for(w = width;w > 0; w--) { - d[0] = (s1[0] + s1[1] + s1[2] + s1[3] + - s2[0] + s2[1] + s2[2] + s2[3] + - s3[0] + s3[1] + s3[2] + s3[3] + - s4[0] + s4[1] + s4[2] + s4[3] + 8) >> 4; - s1 += 4; - s2 += 4; - s3 += 4; - s4 += 4; - d++; - } - src += 4 * 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 -> 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 */ +/* 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) @@ -1063,7 +1391,7 @@ static void build_rgb_palette(uint8_t *palette, int has_alpha) for(r = 0; r < 6; r++) { for(g = 0; g < 6; g++) { for(b = 0; b < 6; b++) { - pal[i++] = (0xff << 24) | (pal_value[r] << 16) | + pal[i++] = (0xff << 24) | (pal_value[r] << 16) | (pal_value[g] << 8) | pal_value[b]; } } @@ -1094,24 +1422,15 @@ static inline unsigned int bitcopy_n(unsigned int a, int n) b = bitcopy_n(v << 3, 3);\ } -#define RGBA_IN(r, g, b, a, 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);\ - a = bitcopy_n(v >> 15, 7);\ -} -#define RGBA_OUT(d, r, g, b, a)\ +#define RGB_OUT(d, r, g, b)\ {\ - ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | \ - ((a << 8) & 0x8000);\ + ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);\ } #define BPP 2 -#include "imgconvert_template.h" +#include "imgconvert_template.c" /* rgb565 handling */ @@ -1132,7 +1451,7 @@ static inline unsigned int bitcopy_n(unsigned int a, int n) #define BPP 2 -#include "imgconvert_template.h" +#include "imgconvert_template.c" /* bgr24 handling */ @@ -1154,7 +1473,7 @@ static inline unsigned int bitcopy_n(unsigned int a, int n) #define BPP 3 -#include "imgconvert_template.h" +#include "imgconvert_template.c" #undef RGB_IN #undef RGB_OUT @@ -1181,12 +1500,12 @@ static inline unsigned int bitcopy_n(unsigned int a, int n) #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)\ {\ @@ -1212,9 +1531,9 @@ static inline unsigned int bitcopy_n(unsigned int a, int n) #define BPP 4 -#include "imgconvert_template.h" +#include "imgconvert_template.c" -static void mono_to_gray(AVPicture *dst, AVPicture *src, +static void mono_to_gray(AVPicture *dst, const AVPicture *src, int width, int height, int xor_mask) { const unsigned char *p; @@ -1228,7 +1547,7 @@ static void mono_to_gray(AVPicture *dst, AVPicture *src, q = dst->data[0]; dst_wrap = dst->linesize[0] - width; for(y=0;y= 8) { v = *p++ ^ xor_mask; q[0] = -(v >> 7); @@ -1255,19 +1574,19 @@ static void mono_to_gray(AVPicture *dst, AVPicture *src, } } -static void monowhite_to_gray(AVPicture *dst, AVPicture *src, +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, AVPicture *src, +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, AVPicture *src, +static void gray_to_mono(AVPicture *dst, const AVPicture *src, int width, int height, int xor_mask) { int n; @@ -1311,276 +1630,760 @@ static void gray_to_mono(AVPicture *dst, AVPicture *src, } } -static void gray_to_monowhite(AVPicture *dst, AVPicture *src, - int width, int height) +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; ydata[0]; + src_wrap = src->linesize[0] - width * 2; + d = dst->data[0]; + dst_wrap = dst->linesize[0] - width; + for(y=0; ydata[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; ydata[0]); +} + +/* return true if yuv planar */ +static inline int is_yuv_planar(const PixFmtInfo *ps) +{ + return (ps->color_type == FF_COLOR_YUV || + ps->color_type == FF_COLOR_YUV_JPEG) && + ps->pixel_type == FF_PIXEL_PLANAR; +} + +int av_picture_crop(AVPicture *dst, const AVPicture *src, + int pix_fmt, int top_band, int left_band) +{ + int y_shift; + int x_shift; + + if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || !is_yuv_planar(&pix_fmt_info[pix_fmt])) + return -1; + + y_shift = pix_fmt_info[pix_fmt].y_chroma_shift; + x_shift = pix_fmt_info[pix_fmt].x_chroma_shift; + + dst->data[0] = src->data[0] + (top_band * src->linesize[0]) + left_band; + dst->data[1] = src->data[1] + ((top_band >> y_shift) * src->linesize[1]) + (left_band >> x_shift); + dst->data[2] = src->data[2] + ((top_band >> y_shift) * src->linesize[2]) + (left_band >> x_shift); + + dst->linesize[0] = src->linesize[0]; + dst->linesize[1] = src->linesize[1]; + dst->linesize[2] = src->linesize[2]; + return 0; +} + +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; + int y_shift; + int x_shift; + int yheight; + int i, y; + + if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB || + !is_yuv_planar(&pix_fmt_info[pix_fmt])) return -1; + + for (i = 0; i < 3; i++) { + x_shift = i ? pix_fmt_info[pix_fmt].x_chroma_shift : 0; + y_shift = i ? pix_fmt_info[pix_fmt].y_chroma_shift : 0; + + if (padtop || padleft) { + memset(dst->data[i], color[i], + dst->linesize[i] * (padtop >> y_shift) + (padleft >> x_shift)); + } + + 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); + memcpy(optr + ((padleft + padright) >> x_shift), iptr, + (width - padleft - padright) >> x_shift); + iptr += src->linesize[i]; + optr += dst->linesize[i]; + } + } + + if (padbottom || padright) { + optr = dst->data[i] + dst->linesize[i] * + ((height - padbottom) >> y_shift) - (padright >> x_shift); + memset(optr, color[i],dst->linesize[i] * + (padbottom >> y_shift) + (padright >> x_shift)); + } + } + return 0; +} + +#if !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) { - gray_to_mono(dst, src, width, height, 0xff); + for(;height > 0; height--) { + grow21_line(dst, src, width); + if (height%2) + src += src_wrap; + dst += dst_wrap; + } } -static void gray_to_monoblack(AVPicture *dst, AVPicture *src, - int width, int height) +/* 1x1 -> 4x1 */ +static void grow41(uint8_t *dst, int dst_wrap, + const uint8_t *src, int src_wrap, + int width, int height) { - gray_to_mono(dst, src, width, height, 0x00); + for(;height > 0; height--) { + grow41_line(dst, src, width); + src += src_wrap; + dst += dst_wrap; + } } -typedef struct ConvertEntry { - void (*convert)(AVPicture *dst, AVPicture *src, int width, int height); -} ConvertEntry; - -/* Add each new convertion 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_RGBA32 - - - 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. -*/ -static ConvertEntry convert_table[PIX_FMT_NB][PIX_FMT_NB] = { - [PIX_FMT_YUV420P] = { - [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_RGBA32] = { - .convert = yuv420p_to_rgba32 - }, - }, - [PIX_FMT_YUV422P] = { - [PIX_FMT_YUV422] = { - .convert = yuv422p_to_yuv422, - }, - }, - [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_RGBA32] = { - .convert = yuvj420p_to_rgba32 - }, - }, - [PIX_FMT_YUVJ444P] = { - [PIX_FMT_RGB24] = { - .convert = yuvj444p_to_rgb24 - }, - }, - [PIX_FMT_YUV422] = { - [PIX_FMT_YUV420P] = { - .convert = yuv422_to_yuv420p, - }, - [PIX_FMT_YUV422P] = { - .convert = yuv422_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_RGBA32] = { - .convert = rgb24_to_rgba32 - }, - [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_RGBA32] = { - [PIX_FMT_RGB24] = { - .convert = rgba32_to_rgb24 - }, - [PIX_FMT_RGB555] = { - .convert = rgba32_to_rgb555 - }, - [PIX_FMT_PAL8] = { - .convert = rgba32_to_pal8 - }, - [PIX_FMT_YUV420P] = { - .convert = rgba32_to_yuv420p - }, - [PIX_FMT_GRAY8] = { - .convert = rgba32_to_gray - }, - }, - [PIX_FMT_BGR24] = { - [PIX_FMT_RGB24] = { - .convert = bgr24_to_rgb24 - }, - [PIX_FMT_YUV420P] = { - .convert = bgr24_to_yuv420p - }, - [PIX_FMT_GRAY8] = { - .convert = bgr24_to_gray - }, - }, - [PIX_FMT_RGB555] = { - [PIX_FMT_RGB24] = { - .convert = rgb555_to_rgb24 - }, - [PIX_FMT_RGBA32] = { - .convert = rgb555_to_rgba32 - }, - [PIX_FMT_YUV420P] = { - .convert = rgb555_to_yuv420p - }, - [PIX_FMT_GRAY8] = { - .convert = rgb555_to_gray - }, - }, - [PIX_FMT_RGB565] = { - [PIX_FMT_RGB24] = { - .convert = rgb565_to_rgb24 - }, - [PIX_FMT_YUV420P] = { - .convert = rgb565_to_yuv420p - }, - [PIX_FMT_GRAY8] = { - .convert = rgb565_to_gray - }, - }, - [PIX_FMT_GRAY8] = { - [PIX_FMT_RGB555] = { - .convert = gray_to_rgb555 - }, - [PIX_FMT_RGB565] = { - .convert = gray_to_rgb565 - }, - [PIX_FMT_RGB24] = { - .convert = gray_to_rgb24 - }, - [PIX_FMT_BGR24] = { - .convert = gray_to_bgr24 - }, - [PIX_FMT_RGBA32] = { - .convert = gray_to_rgba32 - }, - [PIX_FMT_MONOWHITE] = { - .convert = gray_to_monowhite - }, - [PIX_FMT_MONOBLACK] = { - .convert = gray_to_monoblack - }, - }, - [PIX_FMT_MONOWHITE] = { - [PIX_FMT_GRAY8] = { - .convert = monowhite_to_gray - }, - }, - [PIX_FMT_MONOBLACK] = { - [PIX_FMT_GRAY8] = { - .convert = monoblack_to_gray - }, - }, - [PIX_FMT_PAL8] = { - [PIX_FMT_RGB555] = { - .convert = pal8_to_rgb555 - }, - [PIX_FMT_RGB565] = { - .convert = pal8_to_rgb565 - }, - [PIX_FMT_BGR24] = { - .convert = pal8_to_bgr24 - }, - [PIX_FMT_RGB24] = { - .convert = pal8_to_rgb24 - }, - [PIX_FMT_RGBA32] = { - .convert = pal8_to_rgba32 - }, - }, -}; - -static int avpicture_alloc(AVPicture *picture, - int pix_fmt, int width, int height) +/* 1x1 -> 4x4 */ +static void grow44(uint8_t *dst, int dst_wrap, + const uint8_t *src, int src_wrap, + int width, int height) { - unsigned int size; - void *ptr; - - size = avpicture_get_size(pix_fmt, width, height); - if (size < 0) - goto fail; - ptr = av_malloc(size); - if (!ptr) - goto fail; - avpicture_fill(picture, ptr, pix_fmt, width, height); - return 0; - fail: - memset(picture, 0, sizeof(AVPicture)); - return -1; + for(;height > 0; height--) { + grow41_line(dst, src, width); + if ((height & 3) == 1) + src += src_wrap; + dst += dst_wrap; + } } -static void avpicture_free(AVPicture *picture) +/* 1x2 -> 2x1 */ +static void conv411(uint8_t *dst, int dst_wrap, + const uint8_t *src, int src_wrap, + int width, int height) { - av_free(picture->data[0]); -} + int w, c; + const uint8_t *s1, *s2; + uint8_t *d; -/* return true if yuv planar */ -static inline int is_yuv_planar(PixFmtInfo *ps) -{ - return (ps->color_type == FF_COLOR_YUV || - ps->color_type == FF_COLOR_YUV_JPEG) && - ps->pixel_type == FF_PIXEL_PLANAR; + 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, - AVPicture *src, int src_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; - PixFmtInfo *src_pix, *dst_pix; - ConvertEntry *ce; + const PixFmtInfo *src_pix, *dst_pix; + const ConvertEntry *ce; AVPicture tmp1, *tmp = &tmp1; if (src_pix_fmt < 0 || src_pix_fmt >= PIX_FMT_NB || @@ -1589,8 +2392,8 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, if (src_width <= 0 || src_height <= 0) return 0; - if (!inited) { - inited = 1; + if (!initialized) { + initialized = 1; img_convert_init(); } @@ -1601,13 +2404,13 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, 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; } ce = &convert_table[src_pix_fmt][dst_pix_fmt]; if (ce->convert) { - /* specific convertion routine */ + /* specific conversion routine */ ce->convert(dst, src, dst_width, dst_height); return 0; } @@ -1619,7 +2422,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, uint8_t *d; if (dst_pix->color_type == FF_COLOR_YUV_JPEG) { - img_copy_plane(dst->data[0], dst->linesize[0], + ff_img_copy_plane(dst->data[0], dst->linesize[0], src->data[0], src->linesize[0], dst_width, dst_height); } else { @@ -1644,10 +2447,10 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, } /* YUV to gray */ - if (is_yuv_planar(src_pix) && + if (is_yuv_planar(src_pix) && dst_pix_fmt == PIX_FMT_GRAY8) { if (src_pix->color_type == FF_COLOR_YUV_JPEG) { - img_copy_plane(dst->data[0], dst->linesize[0], + ff_img_copy_plane(dst->data[0], dst->linesize[0], src->data[0], src->linesize[0], dst_width, dst_height); } else { @@ -1662,7 +2465,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, /* YUV to YUV planar */ if (is_yuv_planar(dst_pix) && is_yuv_planar(src_pix)) { int x_shift, y_shift, w, h, xy_shift; - void (*resize_func)(uint8_t *dst, int dst_wrap, + void (*resize_func)(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); @@ -1685,7 +2488,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, YUV444 format */ switch(xy_shift) { case 0x00: - resize_func = img_copy_plane; + resize_func = ff_img_copy_plane; break; case 0x10: resize_func = shrink21; @@ -1697,14 +2500,17 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, resize_func = shrink12; break; case 0x11: - resize_func = shrink22; + resize_func = ff_shrink22; break; case 0x22: - resize_func = shrink44; + resize_func = ff_shrink44; break; case 0xf0: resize_func = grow21; break; + case 0x0f: + resize_func = grow12; + break; case 0xe0: resize_func = grow41; break; @@ -1722,7 +2528,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, goto no_chroma_filter; } - img_copy_plane(dst->data[0], dst->linesize[0], + ff_img_copy_plane(dst->data[0], dst->linesize[0], src->data[0], src->linesize[0], dst_width, dst_height); @@ -1749,7 +2555,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, for(i = 1;i <= 2; i++) img_apply_table(dst->data[i], dst->linesize[i], dst->data[i], dst->linesize[i], - dst_width>>dst_pix->x_chroma_shift, + dst_width>>dst_pix->x_chroma_shift, dst_height>>dst_pix->y_chroma_shift, c_table); } @@ -1758,17 +2564,25 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, 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_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 && - src_pix_fmt != PIX_FMT_GRAY8) || + src_pix_fmt != PIX_FMT_GRAY8) || (dst_pix->color_type == FF_COLOR_GRAY && dst_pix_fmt != PIX_FMT_GRAY8)) { /* gray8 is the normalized format */ int_pix_fmt = PIX_FMT_GRAY8; - } else if ((is_yuv_planar(src_pix) && + } else if ((is_yuv_planar(src_pix) && src_pix_fmt != PIX_FMT_YUV444P && src_pix_fmt != PIX_FMT_YUVJ444P)) { /* yuv444 is the normalized format */ @@ -1776,7 +2590,7 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, int_pix_fmt = PIX_FMT_YUVJ444P; else int_pix_fmt = PIX_FMT_YUV444P; - } else if ((is_yuv_planar(dst_pix) && + } else if ((is_yuv_planar(dst_pix) && dst_pix_fmt != PIX_FMT_YUV444P && dst_pix_fmt != PIX_FMT_YUVJ444P)) { /* yuv444 is the normalized format */ @@ -1787,10 +2601,12 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, } 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; @@ -1805,9 +2621,60 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, avpicture_free(tmp); return ret; } +#endif + +/* NOTE: we scan all the pixels to have an exact information */ +static int get_alpha_info_pal8(const AVPicture *src, int width, int height) +{ + const unsigned char *p; + int src_wrap, ret, x, y; + unsigned int a; + uint32_t *palette = (uint32_t *)src->data[1]; + + p = src->data[0]; + src_wrap = src->linesize[0] - width; + ret = 0; + for(y=0;y> 24; + if (a == 0x00) { + ret |= FF_ALPHA_TRANSP; + } else if (a != 0xff) { + ret |= FF_ALPHA_SEMI_TRANSP; + } + p++; + } + p += src_wrap; + } + return ret; +} + +int img_get_alpha_info(const AVPicture *src, + int pix_fmt, int width, int height) +{ + const PixFmtInfo *pf = &pix_fmt_info[pix_fmt]; + int ret; + pf = &pix_fmt_info[pix_fmt]; + /* no alpha can be represented in format */ + if (!pf->is_alpha) + return 0; + switch(pix_fmt) { + 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); + break; + default: + /* we do not know, so everything is indicated */ + ret = FF_ALPHA_TRANSP | FF_ALPHA_SEMI_TRANSP; + break; + } + return ret; +} -#ifdef HAVE_MMX +#if HAVE_MMX #define DEINT_INPLACE_LINE_LUM \ movd_m2r(lum_m4[0],mm0);\ movd_m2r(lum_m3[0],mm1);\ @@ -1855,11 +2722,14 @@ int img_convert(AVPicture *dst, int dst_pix_fmt, #endif /* filter parameters: [-1 4 2 4 -1] // 8 */ -static void deinterlace_line(uint8_t *dst, uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum, - int size) +static void deinterlace_line(uint8_t *dst, + const uint8_t *lum_m4, const uint8_t *lum_m3, + const uint8_t *lum_m2, const uint8_t *lum_m1, + const uint8_t *lum, + int size) { -#ifndef HAVE_MMX - uint8_t *cm = cropTbl + MAX_NEG_CROP; +#if !HAVE_MMX + uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; int sum; for(;size > 0;size--) { @@ -1879,13 +2749,8 @@ static void deinterlace_line(uint8_t *dst, uint8_t *lum_m4, uint8_t *lum_m3, uin #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 @@ -1901,8 +2766,8 @@ static void deinterlace_line(uint8_t *dst, uint8_t *lum_m4, uint8_t *lum_m3, uin static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum, int size) { -#ifndef HAVE_MMX - uint8_t *cm = cropTbl + MAX_NEG_CROP; +#if !HAVE_MMX + uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; int sum; for(;size > 0;size--) { @@ -1922,13 +2787,8 @@ static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t * #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 @@ -1945,10 +2805,10 @@ static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t * top field is copied as is, but the bottom field is deinterlaced against the top field. */ static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap, - uint8_t *src1, int src_wrap, + const uint8_t *src1, int src_wrap, int width, int height) { - uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; + const uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2; int y; src_m2 = src1; @@ -1974,7 +2834,7 @@ static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap, } static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, - int width, int height) + int width, int height) { uint8_t *src_m1, *src_0, *src_p1, *src_p2; int y; @@ -1998,16 +2858,16 @@ static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap, av_free(buf); } - -/* deinterlace - if not supported return -1 */ -int avpicture_deinterlace(AVPicture *dst, AVPicture *src, +int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, int pix_fmt, int width, int height) { int i; if (pix_fmt != PIX_FMT_YUV420P && pix_fmt != PIX_FMT_YUV422P && - pix_fmt != PIX_FMT_YUV444P) + pix_fmt != PIX_FMT_YUV444P && + pix_fmt != PIX_FMT_YUV411P && + pix_fmt != PIX_FMT_GRAY8) return -1; if ((width & 3) != 0 || (height & 3) != 0) return -1; @@ -2022,12 +2882,18 @@ int avpicture_deinterlace(AVPicture *dst, AVPicture *src, case PIX_FMT_YUV422P: width >>= 1; break; + case PIX_FMT_YUV411P: + width >>= 2; + break; default: break; } + if (pix_fmt == PIX_FMT_GRAY8) { + break; + } } if (src == dst) { - deinterlace_bottom_field_inplace(src->data[i], src->linesize[i], + deinterlace_bottom_field_inplace(dst->data[i], dst->linesize[i], width, height); } else { deinterlace_bottom_field(dst->data[i],dst->linesize[i], @@ -2035,10 +2901,7 @@ int avpicture_deinterlace(AVPicture *dst, AVPicture *src, width, height); } } -#ifdef HAVE_MMX - emms(); -#endif + emms_c(); return 0; } -#undef FIX