mirror of https://github.com/FFmpeg/FFmpeg.git
Originally committed as revision 17786 to svn://svn.ffmpeg.org/ffmpeg/trunkrelease/0.6
Michael Niedermayer
16 years ago
parent
1ad1eaadd6
commit
6d4f53cbac
10 changed files with 2 additions and 3400 deletions
File diff suppressed because it is too large
Load Diff
@ -1,875 +0,0 @@ |
||||
/*
|
||||
* templates for image conversion routines |
||||
* Copyright (c) 2001, 2002, 2003 Fabrice Bellard |
||||
* |
||||
* 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.1 of the License, or (at your option) any later version. |
||||
* |
||||
* 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 FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef RGB_OUT |
||||
#define RGB_OUT(d, r, g, b) RGBA_OUT(d, r, g, b, 0xff) |
||||
#endif |
||||
|
||||
static void glue(yuv420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr; |
||||
uint8_t *d, *d1, *d2; |
||||
int w, y, cb, cr, r_add, g_add, b_add, width2; |
||||
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
||||
unsigned int r, g, b; |
||||
|
||||
d = dst->data[0]; |
||||
y1_ptr = src->data[0]; |
||||
cb_ptr = src->data[1]; |
||||
cr_ptr = src->data[2]; |
||||
width2 = (width + 1) >> 1; |
||||
for(;height >= 2; height -= 2) { |
||||
d1 = d; |
||||
d2 = d + dst->linesize[0]; |
||||
y2_ptr = y1_ptr + src->linesize[0]; |
||||
for(w = width; w >= 2; w -= 2) { |
||||
YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); |
||||
/* output 4 pixels */ |
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]); |
||||
RGB_OUT(d1 + BPP, r, g, b); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]); |
||||
RGB_OUT(d2, r, g, b); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[1]); |
||||
RGB_OUT(d2 + BPP, r, g, b); |
||||
|
||||
d1 += 2 * BPP; |
||||
d2 += 2 * BPP; |
||||
|
||||
y1_ptr += 2; |
||||
y2_ptr += 2; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
/* handle odd width */ |
||||
if (w) { |
||||
YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); |
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y2_ptr[0]); |
||||
RGB_OUT(d2, r, g, b); |
||||
d1 += BPP; |
||||
d2 += BPP; |
||||
y1_ptr++; |
||||
y2_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
d += 2 * dst->linesize[0]; |
||||
y1_ptr += 2 * src->linesize[0] - width; |
||||
cb_ptr += src->linesize[1] - width2; |
||||
cr_ptr += src->linesize[2] - width2; |
||||
} |
||||
/* handle odd height */ |
||||
if (height) { |
||||
d1 = d; |
||||
for(w = width; w >= 2; w -= 2) { |
||||
YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); |
||||
/* output 2 pixels */ |
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[1]); |
||||
RGB_OUT(d1 + BPP, r, g, b); |
||||
|
||||
d1 += 2 * BPP; |
||||
|
||||
y1_ptr += 2; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
/* handle width */ |
||||
if (w) { |
||||
YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); |
||||
/* output 2 pixels */ |
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
d1 += BPP; |
||||
|
||||
y1_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void glue(yuvj420p_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr; |
||||
uint8_t *d, *d1, *d2; |
||||
int w, y, cb, cr, r_add, g_add, b_add, width2; |
||||
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
||||
unsigned int r, g, b; |
||||
|
||||
d = dst->data[0]; |
||||
y1_ptr = src->data[0]; |
||||
cb_ptr = src->data[1]; |
||||
cr_ptr = src->data[2]; |
||||
width2 = (width + 1) >> 1; |
||||
for(;height >= 2; height -= 2) { |
||||
d1 = d; |
||||
d2 = d + dst->linesize[0]; |
||||
y2_ptr = y1_ptr + src->linesize[0]; |
||||
for(w = width; w >= 2; w -= 2) { |
||||
YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); |
||||
/* output 4 pixels */ |
||||
YUV_TO_RGB2(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y1_ptr[1]); |
||||
RGB_OUT(d1 + BPP, r, g, b); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y2_ptr[0]); |
||||
RGB_OUT(d2, r, g, b); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y2_ptr[1]); |
||||
RGB_OUT(d2 + BPP, r, g, b); |
||||
|
||||
d1 += 2 * BPP; |
||||
d2 += 2 * BPP; |
||||
|
||||
y1_ptr += 2; |
||||
y2_ptr += 2; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
/* handle odd width */ |
||||
if (w) { |
||||
YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); |
||||
YUV_TO_RGB2(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y2_ptr[0]); |
||||
RGB_OUT(d2, r, g, b); |
||||
d1 += BPP; |
||||
d2 += BPP; |
||||
y1_ptr++; |
||||
y2_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
d += 2 * dst->linesize[0]; |
||||
y1_ptr += 2 * src->linesize[0] - width; |
||||
cb_ptr += src->linesize[1] - width2; |
||||
cr_ptr += src->linesize[2] - width2; |
||||
} |
||||
/* handle odd height */ |
||||
if (height) { |
||||
d1 = d; |
||||
for(w = width; w >= 2; w -= 2) { |
||||
YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); |
||||
/* output 2 pixels */ |
||||
YUV_TO_RGB2(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y1_ptr[1]); |
||||
RGB_OUT(d1 + BPP, r, g, b); |
||||
|
||||
d1 += 2 * BPP; |
||||
|
||||
y1_ptr += 2; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
/* handle width */ |
||||
if (w) { |
||||
YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); |
||||
/* output 2 pixels */ |
||||
YUV_TO_RGB2(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
d1 += BPP; |
||||
|
||||
y1_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void glue(RGB_NAME, _to_yuv420p)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
int wrap, wrap3, width2; |
||||
int r, g, b, r1, g1, b1, w; |
||||
uint8_t *lum, *cb, *cr; |
||||
const uint8_t *p; |
||||
|
||||
lum = dst->data[0]; |
||||
cb = dst->data[1]; |
||||
cr = dst->data[2]; |
||||
|
||||
width2 = (width + 1) >> 1; |
||||
wrap = dst->linesize[0]; |
||||
wrap3 = src->linesize[0]; |
||||
p = src->data[0]; |
||||
for(;height>=2;height -= 2) { |
||||
for(w = width; w >= 2; w -= 2) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y_CCIR(r, g, b); |
||||
p += wrap3; |
||||
lum += wrap; |
||||
|
||||
RGB_IN(r, g, b, p); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y_CCIR(r, g, b); |
||||
|
||||
cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 2); |
||||
cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 2); |
||||
|
||||
cb++; |
||||
cr++; |
||||
p += -wrap3 + 2 * BPP; |
||||
lum += -wrap + 2; |
||||
} |
||||
if (w) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
p += wrap3; |
||||
lum += wrap; |
||||
RGB_IN(r, g, b, p); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1); |
||||
cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1); |
||||
cb++; |
||||
cr++; |
||||
p += -wrap3 + BPP; |
||||
lum += -wrap + 1; |
||||
} |
||||
p += wrap3 + (wrap3 - width * BPP); |
||||
lum += wrap + (wrap - width); |
||||
cb += dst->linesize[1] - width2; |
||||
cr += dst->linesize[2] - width2; |
||||
} |
||||
/* handle odd height */ |
||||
if (height) { |
||||
for(w = width; w >= 2; w -= 2) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y_CCIR(r, g, b); |
||||
cb[0] = RGB_TO_U_CCIR(r1, g1, b1, 1); |
||||
cr[0] = RGB_TO_V_CCIR(r1, g1, b1, 1); |
||||
cb++; |
||||
cr++; |
||||
p += 2 * BPP; |
||||
lum += 2; |
||||
} |
||||
if (w) { |
||||
RGB_IN(r, g, b, p); |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
cb[0] = RGB_TO_U_CCIR(r, g, b, 0); |
||||
cr[0] = RGB_TO_V_CCIR(r, g, b, 0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void glue(RGB_NAME, _to_gray)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const unsigned char *p; |
||||
unsigned char *q; |
||||
int r, g, b, dst_wrap, src_wrap; |
||||
int x, y; |
||||
|
||||
p = src->data[0]; |
||||
src_wrap = src->linesize[0] - BPP * width; |
||||
|
||||
q = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
RGB_IN(r, g, b, p); |
||||
q[0] = RGB_TO_Y(r, g, b); |
||||
q++; |
||||
p += BPP; |
||||
} |
||||
p += src_wrap; |
||||
q += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
static void glue(gray_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const unsigned char *p; |
||||
unsigned char *q; |
||||
int r, dst_wrap, src_wrap; |
||||
int x, y; |
||||
|
||||
p = src->data[0]; |
||||
src_wrap = src->linesize[0] - width; |
||||
|
||||
q = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - BPP * width; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
r = p[0]; |
||||
RGB_OUT(q, r, r, r); |
||||
q += BPP; |
||||
p ++; |
||||
} |
||||
p += src_wrap; |
||||
q += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
static void glue(pal8_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const unsigned char *p; |
||||
unsigned char *q; |
||||
int r, g, b, dst_wrap, src_wrap; |
||||
int x, y; |
||||
uint32_t v; |
||||
const uint32_t *palette; |
||||
|
||||
p = src->data[0]; |
||||
src_wrap = src->linesize[0] - width; |
||||
palette = (uint32_t *)src->data[1]; |
||||
|
||||
q = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - BPP * width; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
v = palette[p[0]]; |
||||
r = (v >> 16) & 0xff; |
||||
g = (v >> 8) & 0xff; |
||||
b = (v) & 0xff; |
||||
#ifdef RGBA_OUT |
||||
{ |
||||
int a; |
||||
a = (v >> 24) & 0xff; |
||||
RGBA_OUT(q, r, g, b, a); |
||||
} |
||||
#else |
||||
RGB_OUT(q, r, g, b); |
||||
#endif |
||||
q += BPP; |
||||
p ++; |
||||
} |
||||
p += src_wrap; |
||||
q += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
// RGB24 has optimized routines
|
||||
#if !defined(FMT_RGB32) && !defined(FMT_RGB24) |
||||
/* alpha support */ |
||||
|
||||
static void glue(rgb32_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *s; |
||||
uint8_t *d; |
||||
int src_wrap, dst_wrap, j, y; |
||||
unsigned int v, r, g, b; |
||||
#ifdef RGBA_OUT |
||||
unsigned int a; |
||||
#endif |
||||
|
||||
s = src->data[0]; |
||||
src_wrap = src->linesize[0] - width * 4; |
||||
|
||||
d = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width * BPP; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(j = 0;j < width; j++) { |
||||
v = ((const uint32_t *)(s))[0]; |
||||
r = (v >> 16) & 0xff; |
||||
g = (v >> 8) & 0xff; |
||||
b = v & 0xff; |
||||
#ifdef RGBA_OUT |
||||
a = (v >> 24) & 0xff; |
||||
RGBA_OUT(d, r, g, b, a); |
||||
#else |
||||
RGB_OUT(d, r, g, b); |
||||
#endif |
||||
s += 4; |
||||
d += BPP; |
||||
} |
||||
s += src_wrap; |
||||
d += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
static void glue(RGB_NAME, _to_rgb32)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *s; |
||||
uint8_t *d; |
||||
int src_wrap, dst_wrap, j, y; |
||||
unsigned int r, g, b; |
||||
#ifdef RGBA_IN |
||||
unsigned int a; |
||||
#endif |
||||
|
||||
s = src->data[0]; |
||||
src_wrap = src->linesize[0] - width * BPP; |
||||
|
||||
d = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width * 4; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(j = 0;j < width; j++) { |
||||
#ifdef RGBA_IN |
||||
RGBA_IN(r, g, b, a, s); |
||||
((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b; |
||||
#else |
||||
RGB_IN(r, g, b, s); |
||||
((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b; |
||||
#endif |
||||
d += 4; |
||||
s += BPP; |
||||
} |
||||
s += src_wrap; |
||||
d += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
#endif /* !defined(FMT_RGB32) */ |
||||
|
||||
#ifndef FMT_RGB24 |
||||
|
||||
static void glue(rgb24_to_, RGB_NAME)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *s; |
||||
uint8_t *d; |
||||
int src_wrap, dst_wrap, j, y; |
||||
unsigned int r, g, b; |
||||
|
||||
s = src->data[0]; |
||||
src_wrap = src->linesize[0] - width * 3; |
||||
|
||||
d = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width * BPP; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(j = 0;j < width; j++) { |
||||
r = s[0]; |
||||
g = s[1]; |
||||
b = s[2]; |
||||
RGB_OUT(d, r, g, b); |
||||
s += 3; |
||||
d += BPP; |
||||
} |
||||
s += src_wrap; |
||||
d += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
static void glue(RGB_NAME, _to_rgb24)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *s; |
||||
uint8_t *d; |
||||
int src_wrap, dst_wrap, j, y; |
||||
unsigned int r, g , b; |
||||
|
||||
s = src->data[0]; |
||||
src_wrap = src->linesize[0] - width * BPP; |
||||
|
||||
d = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width * 3; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(j = 0;j < width; j++) { |
||||
RGB_IN(r, g, b, s) |
||||
d[0] = r; |
||||
d[1] = g; |
||||
d[2] = b; |
||||
d += 3; |
||||
s += BPP; |
||||
} |
||||
s += src_wrap; |
||||
d += dst_wrap; |
||||
} |
||||
} |
||||
|
||||
#endif /* !FMT_RGB24 */ |
||||
|
||||
#ifdef FMT_RGB24 |
||||
|
||||
static void yuv444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *y1_ptr, *cb_ptr, *cr_ptr; |
||||
uint8_t *d, *d1; |
||||
int w, y, cb, cr, r_add, g_add, b_add; |
||||
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
||||
unsigned int r, g, b; |
||||
|
||||
d = dst->data[0]; |
||||
y1_ptr = src->data[0]; |
||||
cb_ptr = src->data[1]; |
||||
cr_ptr = src->data[2]; |
||||
for(;height > 0; height --) { |
||||
d1 = d; |
||||
for(w = width; w > 0; w--) { |
||||
YUV_TO_RGB1_CCIR(cb_ptr[0], cr_ptr[0]); |
||||
|
||||
YUV_TO_RGB2_CCIR(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
d1 += BPP; |
||||
|
||||
y1_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
d += dst->linesize[0]; |
||||
y1_ptr += src->linesize[0] - width; |
||||
cb_ptr += src->linesize[1] - width; |
||||
cr_ptr += src->linesize[2] - width; |
||||
} |
||||
} |
||||
|
||||
static void yuvj444p_to_rgb24(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const uint8_t *y1_ptr, *cb_ptr, *cr_ptr; |
||||
uint8_t *d, *d1; |
||||
int w, y, cb, cr, r_add, g_add, b_add; |
||||
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
||||
unsigned int r, g, b; |
||||
|
||||
d = dst->data[0]; |
||||
y1_ptr = src->data[0]; |
||||
cb_ptr = src->data[1]; |
||||
cr_ptr = src->data[2]; |
||||
for(;height > 0; height --) { |
||||
d1 = d; |
||||
for(w = width; w > 0; w--) { |
||||
YUV_TO_RGB1(cb_ptr[0], cr_ptr[0]); |
||||
|
||||
YUV_TO_RGB2(r, g, b, y1_ptr[0]); |
||||
RGB_OUT(d1, r, g, b); |
||||
d1 += BPP; |
||||
|
||||
y1_ptr++; |
||||
cb_ptr++; |
||||
cr_ptr++; |
||||
} |
||||
d += dst->linesize[0]; |
||||
y1_ptr += src->linesize[0] - width; |
||||
cb_ptr += src->linesize[1] - width; |
||||
cr_ptr += src->linesize[2] - width; |
||||
} |
||||
} |
||||
|
||||
static void rgb24_to_yuv444p(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
int src_wrap, x, y; |
||||
int r, g, b; |
||||
uint8_t *lum, *cb, *cr; |
||||
const uint8_t *p; |
||||
|
||||
lum = dst->data[0]; |
||||
cb = dst->data[1]; |
||||
cr = dst->data[2]; |
||||
|
||||
src_wrap = src->linesize[0] - width * BPP; |
||||
p = src->data[0]; |
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
RGB_IN(r, g, b, p); |
||||
lum[0] = RGB_TO_Y_CCIR(r, g, b); |
||||
cb[0] = RGB_TO_U_CCIR(r, g, b, 0); |
||||
cr[0] = RGB_TO_V_CCIR(r, g, b, 0); |
||||
p += BPP; |
||||
cb++; |
||||
cr++; |
||||
lum++; |
||||
} |
||||
p += src_wrap; |
||||
lum += dst->linesize[0] - width; |
||||
cb += dst->linesize[1] - width; |
||||
cr += dst->linesize[2] - width; |
||||
} |
||||
} |
||||
|
||||
static void rgb24_to_yuvj420p(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
int wrap, wrap3, width2; |
||||
int r, g, b, r1, g1, b1, w; |
||||
uint8_t *lum, *cb, *cr; |
||||
const uint8_t *p; |
||||
|
||||
lum = dst->data[0]; |
||||
cb = dst->data[1]; |
||||
cr = dst->data[2]; |
||||
|
||||
width2 = (width + 1) >> 1; |
||||
wrap = dst->linesize[0]; |
||||
wrap3 = src->linesize[0]; |
||||
p = src->data[0]; |
||||
for(;height>=2;height -= 2) { |
||||
for(w = width; w >= 2; w -= 2) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y(r, g, b); |
||||
p += wrap3; |
||||
lum += wrap; |
||||
|
||||
RGB_IN(r, g, b, p); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y(r, g, b); |
||||
|
||||
cb[0] = RGB_TO_U(r1, g1, b1, 2); |
||||
cr[0] = RGB_TO_V(r1, g1, b1, 2); |
||||
|
||||
cb++; |
||||
cr++; |
||||
p += -wrap3 + 2 * BPP; |
||||
lum += -wrap + 2; |
||||
} |
||||
if (w) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
p += wrap3; |
||||
lum += wrap; |
||||
RGB_IN(r, g, b, p); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
cb[0] = RGB_TO_U(r1, g1, b1, 1); |
||||
cr[0] = RGB_TO_V(r1, g1, b1, 1); |
||||
cb++; |
||||
cr++; |
||||
p += -wrap3 + BPP; |
||||
lum += -wrap + 1; |
||||
} |
||||
p += wrap3 + (wrap3 - width * BPP); |
||||
lum += wrap + (wrap - width); |
||||
cb += dst->linesize[1] - width2; |
||||
cr += dst->linesize[2] - width2; |
||||
} |
||||
/* handle odd height */ |
||||
if (height) { |
||||
for(w = width; w >= 2; w -= 2) { |
||||
RGB_IN(r, g, b, p); |
||||
r1 = r; |
||||
g1 = g; |
||||
b1 = b; |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
|
||||
RGB_IN(r, g, b, p + BPP); |
||||
r1 += r; |
||||
g1 += g; |
||||
b1 += b; |
||||
lum[1] = RGB_TO_Y(r, g, b); |
||||
cb[0] = RGB_TO_U(r1, g1, b1, 1); |
||||
cr[0] = RGB_TO_V(r1, g1, b1, 1); |
||||
cb++; |
||||
cr++; |
||||
p += 2 * BPP; |
||||
lum += 2; |
||||
} |
||||
if (w) { |
||||
RGB_IN(r, g, b, p); |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
cb[0] = RGB_TO_U(r, g, b, 0); |
||||
cr[0] = RGB_TO_V(r, g, b, 0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void rgb24_to_yuvj444p(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
int src_wrap, x, y; |
||||
int r, g, b; |
||||
uint8_t *lum, *cb, *cr; |
||||
const uint8_t *p; |
||||
|
||||
lum = dst->data[0]; |
||||
cb = dst->data[1]; |
||||
cr = dst->data[2]; |
||||
|
||||
src_wrap = src->linesize[0] - width * BPP; |
||||
p = src->data[0]; |
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
RGB_IN(r, g, b, p); |
||||
lum[0] = RGB_TO_Y(r, g, b); |
||||
cb[0] = RGB_TO_U(r, g, b, 0); |
||||
cr[0] = RGB_TO_V(r, g, b, 0); |
||||
p += BPP; |
||||
cb++; |
||||
cr++; |
||||
lum++; |
||||
} |
||||
p += src_wrap; |
||||
lum += dst->linesize[0] - width; |
||||
cb += dst->linesize[1] - width; |
||||
cr += dst->linesize[2] - width; |
||||
} |
||||
} |
||||
|
||||
#endif /* FMT_RGB24 */ |
||||
|
||||
#if defined(FMT_RGB24) || defined(FMT_RGB32) |
||||
|
||||
static void glue(RGB_NAME, _to_pal8)(AVPicture *dst, const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const unsigned char *p; |
||||
unsigned char *q; |
||||
int dst_wrap, src_wrap; |
||||
int x, y, has_alpha; |
||||
unsigned int r, g, b; |
||||
|
||||
p = src->data[0]; |
||||
src_wrap = src->linesize[0] - BPP * width; |
||||
|
||||
q = dst->data[0]; |
||||
dst_wrap = dst->linesize[0] - width; |
||||
has_alpha = 0; |
||||
|
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
#ifdef RGBA_IN |
||||
{ |
||||
unsigned int a; |
||||
RGBA_IN(r, g, b, a, p); |
||||
/* crude approximation for alpha ! */ |
||||
if (a < 0x80) { |
||||
has_alpha = 1; |
||||
q[0] = TRANSP_INDEX; |
||||
} else { |
||||
q[0] = gif_clut_index(r, g, b); |
||||
} |
||||
} |
||||
#else |
||||
RGB_IN(r, g, b, p); |
||||
q[0] = gif_clut_index(r, g, b); |
||||
#endif |
||||
q++; |
||||
p += BPP; |
||||
} |
||||
p += src_wrap; |
||||
q += dst_wrap; |
||||
} |
||||
|
||||
build_rgb_palette(dst->data[1], has_alpha); |
||||
} |
||||
|
||||
#endif /* defined(FMT_RGB24) || defined(FMT_RGB32) */ |
||||
|
||||
#ifdef RGBA_IN |
||||
|
||||
static int glue(get_alpha_info_, RGB_NAME)(const AVPicture *src, |
||||
int width, int height) |
||||
{ |
||||
const unsigned char *p; |
||||
int src_wrap, ret, x, y; |
||||
unsigned int r, g, b, a; |
||||
|
||||
p = src->data[0]; |
||||
src_wrap = src->linesize[0] - BPP * width; |
||||
ret = 0; |
||||
for(y=0;y<height;y++) { |
||||
for(x=0;x<width;x++) { |
||||
RGBA_IN(r, g, b, a, p); |
||||
if (a == 0x00) { |
||||
ret |= FF_ALPHA_TRANSP; |
||||
} else if (a != 0xff) { |
||||
ret |= FF_ALPHA_SEMI_TRANSP; |
||||
} |
||||
p += BPP; |
||||
} |
||||
p += src_wrap; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
#endif /* RGBA_IN */ |
||||
|
||||
#undef RGB_IN |
||||
#undef RGBA_IN |
||||
#undef RGB_OUT |
||||
#undef RGBA_OUT |
||||
#undef BPP |
||||
#undef RGB_NAME |
||||
#undef FMT_RGB24 |
||||
#undef FMT_RGB32 |
||||
@ -1,833 +0,0 @@ |
||||
/*
|
||||
* High quality image resampling with polyphase filters |
||||
* Copyright (c) 2001 Fabrice Bellard |
||||
* |
||||
* 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.1 of the License, or (at your option) any later version. |
||||
* |
||||
* 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 FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
/**
|
||||
* @file libavcodec/imgresample.c |
||||
* High quality image resampling with polyphase filters . |
||||
* |
||||
* WARNING: This file is deprecated and will be removed after FFmpeg 0.5 |
||||
* release, do not lose your time improving it! |
||||
*/ |
||||
|
||||
#include "avcodec.h" |
||||
#include "dsputil.h" |
||||
#include "imgconvert.h" |
||||
#include "libswscale/swscale.h" |
||||
|
||||
#if HAVE_ALTIVEC |
||||
#include "ppc/imgresample_altivec.h" |
||||
#endif |
||||
|
||||
#define NB_COMPONENTS 3 |
||||
|
||||
#define PHASE_BITS 4 |
||||
#define NB_PHASES (1 << PHASE_BITS) |
||||
#define NB_TAPS 4 |
||||
#define FCENTER 1 /* index of the center of the filter */ |
||||
//#define TEST 1 /* Test it */
|
||||
|
||||
#define POS_FRAC_BITS 16 |
||||
#define POS_FRAC (1 << POS_FRAC_BITS) |
||||
/* 6 bits precision is needed for MMX */ |
||||
#define FILTER_BITS 8 |
||||
|
||||
#define LINE_BUF_HEIGHT (NB_TAPS * 4) |
||||
|
||||
struct SwsContext { |
||||
const AVClass *av_class; |
||||
struct ImgReSampleContext *resampling_ctx; |
||||
enum PixelFormat src_pix_fmt, dst_pix_fmt; |
||||
}; |
||||
|
||||
typedef struct ImgReSampleContext { |
||||
int iwidth, iheight, owidth, oheight; |
||||
int topBand, bottomBand, leftBand, rightBand; |
||||
int padtop, padbottom, padleft, padright; |
||||
int pad_owidth, pad_oheight; |
||||
int h_incr, v_incr; |
||||
DECLARE_ALIGNED_8(int16_t, h_filters[NB_PHASES][NB_TAPS]); /* horizontal filters */ |
||||
DECLARE_ALIGNED_8(int16_t, v_filters[NB_PHASES][NB_TAPS]); /* vertical filters */ |
||||
uint8_t *line_buf; |
||||
} ImgReSampleContext; |
||||
|
||||
void av_build_filter(int16_t *filter, double factor, int tap_count, int phase_count, int scale, int type); |
||||
|
||||
static inline int get_phase(int pos) |
||||
{ |
||||
return ((pos) >> (POS_FRAC_BITS - PHASE_BITS)) & ((1 << PHASE_BITS) - 1); |
||||
} |
||||
|
||||
/* This function must be optimized */ |
||||
static void h_resample_fast(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int src_width, int src_start, int src_incr, |
||||
int16_t *filters) |
||||
{ |
||||
int src_pos, phase, sum, i; |
||||
const uint8_t *s; |
||||
int16_t *filter; |
||||
|
||||
src_pos = src_start; |
||||
for(i=0;i<dst_width;i++) { |
||||
#ifdef TEST |
||||
/* test */ |
||||
if ((src_pos >> POS_FRAC_BITS) < 0 || |
||||
(src_pos >> POS_FRAC_BITS) > (src_width - NB_TAPS)) |
||||
av_abort(); |
||||
#endif |
||||
s = src + (src_pos >> POS_FRAC_BITS); |
||||
phase = get_phase(src_pos); |
||||
filter = filters + phase * NB_TAPS; |
||||
#if NB_TAPS == 4 |
||||
sum = s[0] * filter[0] + |
||||
s[1] * filter[1] + |
||||
s[2] * filter[2] + |
||||
s[3] * filter[3]; |
||||
#else |
||||
{ |
||||
int j; |
||||
sum = 0; |
||||
for(j=0;j<NB_TAPS;j++) |
||||
sum += s[j] * filter[j]; |
||||
} |
||||
#endif |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum < 0) |
||||
sum = 0; |
||||
else if (sum > 255) |
||||
sum = 255; |
||||
dst[0] = sum; |
||||
src_pos += src_incr; |
||||
dst++; |
||||
} |
||||
} |
||||
|
||||
/* This function must be optimized */ |
||||
static void v_resample(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int wrap, int16_t *filter) |
||||
{ |
||||
int sum, i; |
||||
const uint8_t *s; |
||||
|
||||
s = src; |
||||
for(i=0;i<dst_width;i++) { |
||||
#if NB_TAPS == 4 |
||||
sum = s[0 * wrap] * filter[0] + |
||||
s[1 * wrap] * filter[1] + |
||||
s[2 * wrap] * filter[2] + |
||||
s[3 * wrap] * filter[3]; |
||||
#else |
||||
{ |
||||
int j; |
||||
uint8_t *s1 = s; |
||||
|
||||
sum = 0; |
||||
for(j=0;j<NB_TAPS;j++) { |
||||
sum += s1[0] * filter[j]; |
||||
s1 += wrap; |
||||
} |
||||
} |
||||
#endif |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum < 0) |
||||
sum = 0; |
||||
else if (sum > 255) |
||||
sum = 255; |
||||
dst[0] = sum; |
||||
dst++; |
||||
s++; |
||||
} |
||||
} |
||||
|
||||
#if HAVE_MMX |
||||
|
||||
#include "x86/mmx.h" |
||||
|
||||
#define FILTER4(reg) \ |
||||
{\
|
||||
s = src + (src_pos >> POS_FRAC_BITS);\
|
||||
phase = get_phase(src_pos);\
|
||||
filter = filters + phase * NB_TAPS;\
|
||||
movq_m2r(*s, reg);\
|
||||
punpcklbw_r2r(mm7, reg);\
|
||||
movq_m2r(*filter, mm6);\
|
||||
pmaddwd_r2r(reg, mm6);\
|
||||
movq_r2r(mm6, reg);\
|
||||
psrlq_i2r(32, reg);\
|
||||
paddd_r2r(mm6, reg);\
|
||||
psrad_i2r(FILTER_BITS, reg);\
|
||||
src_pos += src_incr;\
|
||||
} |
||||
|
||||
#define DUMP(reg) movq_r2m(reg, tmp); printf(#reg "=%016"PRIx64"\n", tmp.uq); |
||||
|
||||
/* XXX: do four pixels at a time */ |
||||
static void h_resample_fast4_mmx(uint8_t *dst, int dst_width, |
||||
const uint8_t *src, int src_width, |
||||
int src_start, int src_incr, int16_t *filters) |
||||
{ |
||||
int src_pos, phase; |
||||
const uint8_t *s; |
||||
int16_t *filter; |
||||
uint64_t tmp; |
||||
|
||||
src_pos = src_start; |
||||
pxor_r2r(mm7, mm7); |
||||
|
||||
while (dst_width >= 4) { |
||||
|
||||
FILTER4(mm0); |
||||
FILTER4(mm1); |
||||
FILTER4(mm2); |
||||
FILTER4(mm3); |
||||
|
||||
packuswb_r2r(mm7, mm0); |
||||
packuswb_r2r(mm7, mm1); |
||||
packuswb_r2r(mm7, mm3); |
||||
packuswb_r2r(mm7, mm2); |
||||
movq_r2m(mm0, tmp); |
||||
dst[0] = tmp & 0xFF; |
||||
movq_r2m(mm1, tmp); |
||||
dst[1] = tmp & 0xFF; |
||||
movq_r2m(mm2, tmp); |
||||
dst[2] = tmp & 0xFF; |
||||
movq_r2m(mm3, tmp); |
||||
dst[3] = tmp & 0xFF; |
||||
dst += 4; |
||||
dst_width -= 4; |
||||
} |
||||
while (dst_width > 0) { |
||||
FILTER4(mm0); |
||||
packuswb_r2r(mm7, mm0); |
||||
movq_r2m(mm0, tmp); |
||||
dst[0] = tmp & 0xFF; |
||||
dst++; |
||||
dst_width--; |
||||
} |
||||
emms(); |
||||
} |
||||
|
||||
static void v_resample4_mmx(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int wrap, int16_t *filter) |
||||
{ |
||||
int sum, i; |
||||
const uint8_t *s; |
||||
uint64_t tmp; |
||||
uint64_t coefs[4]; |
||||
|
||||
for(i=0;i<4;i++) { |
||||
tmp = filter[i]; |
||||
coefs[i] = (tmp<<48) + (tmp<<32) + (tmp<<16) + tmp; |
||||
} |
||||
|
||||
pxor_r2r(mm7, mm7); |
||||
s = src; |
||||
while (dst_width >= 4) { |
||||
movq_m2r(s[0 * wrap], mm0); |
||||
punpcklbw_r2r(mm7, mm0); |
||||
movq_m2r(s[1 * wrap], mm1); |
||||
punpcklbw_r2r(mm7, mm1); |
||||
movq_m2r(s[2 * wrap], mm2); |
||||
punpcklbw_r2r(mm7, mm2); |
||||
movq_m2r(s[3 * wrap], mm3); |
||||
punpcklbw_r2r(mm7, mm3); |
||||
|
||||
pmullw_m2r(coefs[0], mm0); |
||||
pmullw_m2r(coefs[1], mm1); |
||||
pmullw_m2r(coefs[2], mm2); |
||||
pmullw_m2r(coefs[3], mm3); |
||||
|
||||
paddw_r2r(mm1, mm0); |
||||
paddw_r2r(mm3, mm2); |
||||
paddw_r2r(mm2, mm0); |
||||
psraw_i2r(FILTER_BITS, mm0); |
||||
|
||||
packuswb_r2r(mm7, mm0); |
||||
movq_r2m(mm0, tmp); |
||||
|
||||
*(uint32_t *)dst = tmp & 0xFFFFFFFF; |
||||
dst += 4; |
||||
s += 4; |
||||
dst_width -= 4; |
||||
} |
||||
while (dst_width > 0) { |
||||
sum = s[0 * wrap] * filter[0] + |
||||
s[1 * wrap] * filter[1] + |
||||
s[2 * wrap] * filter[2] + |
||||
s[3 * wrap] * filter[3]; |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum < 0) |
||||
sum = 0; |
||||
else if (sum > 255) |
||||
sum = 255; |
||||
dst[0] = sum; |
||||
dst++; |
||||
s++; |
||||
dst_width--; |
||||
} |
||||
emms(); |
||||
} |
||||
#endif /* HAVE_MMX */ |
||||
|
||||
/* slow version to handle limit cases. Does not need optimization */ |
||||
static void h_resample_slow(uint8_t *dst, int dst_width, |
||||
const uint8_t *src, int src_width, |
||||
int src_start, int src_incr, int16_t *filters) |
||||
{ |
||||
int src_pos, phase, sum, j, v, i; |
||||
const uint8_t *s, *src_end; |
||||
int16_t *filter; |
||||
|
||||
src_end = src + src_width; |
||||
src_pos = src_start; |
||||
for(i=0;i<dst_width;i++) { |
||||
s = src + (src_pos >> POS_FRAC_BITS); |
||||
phase = get_phase(src_pos); |
||||
filter = filters + phase * NB_TAPS; |
||||
sum = 0; |
||||
for(j=0;j<NB_TAPS;j++) { |
||||
if (s < src) |
||||
v = src[0]; |
||||
else if (s >= src_end) |
||||
v = src_end[-1]; |
||||
else |
||||
v = s[0]; |
||||
sum += v * filter[j]; |
||||
s++; |
||||
} |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum < 0) |
||||
sum = 0; |
||||
else if (sum > 255) |
||||
sum = 255; |
||||
dst[0] = sum; |
||||
src_pos += src_incr; |
||||
dst++; |
||||
} |
||||
} |
||||
|
||||
static void h_resample(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int src_width, int src_start, int src_incr, |
||||
int16_t *filters) |
||||
{ |
||||
int n, src_end; |
||||
|
||||
if (src_start < 0) { |
||||
n = (0 - src_start + src_incr - 1) / src_incr; |
||||
h_resample_slow(dst, n, src, src_width, src_start, src_incr, filters); |
||||
dst += n; |
||||
dst_width -= n; |
||||
src_start += n * src_incr; |
||||
} |
||||
src_end = src_start + dst_width * src_incr; |
||||
if (src_end > ((src_width - NB_TAPS) << POS_FRAC_BITS)) { |
||||
n = (((src_width - NB_TAPS + 1) << POS_FRAC_BITS) - 1 - src_start) / |
||||
src_incr; |
||||
} else { |
||||
n = dst_width; |
||||
} |
||||
#if HAVE_MMX |
||||
if ((mm_flags & FF_MM_MMX) && NB_TAPS == 4) |
||||
h_resample_fast4_mmx(dst, n, |
||||
src, src_width, src_start, src_incr, filters); |
||||
else |
||||
#endif |
||||
h_resample_fast(dst, n, |
||||
src, src_width, src_start, src_incr, filters); |
||||
if (n < dst_width) { |
||||
dst += n; |
||||
dst_width -= n; |
||||
src_start += n * src_incr; |
||||
h_resample_slow(dst, dst_width, |
||||
src, src_width, src_start, src_incr, filters); |
||||
} |
||||
} |
||||
|
||||
static void component_resample(ImgReSampleContext *s, |
||||
uint8_t *output, int owrap, int owidth, int oheight, |
||||
uint8_t *input, int iwrap, int iwidth, int iheight) |
||||
{ |
||||
int src_y, src_y1, last_src_y, ring_y, phase_y, y1, y; |
||||
uint8_t *new_line, *src_line; |
||||
|
||||
last_src_y = - FCENTER - 1; |
||||
/* position of the bottom of the filter in the source image */ |
||||
src_y = (last_src_y + NB_TAPS) * POS_FRAC; |
||||
ring_y = NB_TAPS; /* position in ring buffer */ |
||||
for(y=0;y<oheight;y++) { |
||||
/* apply horizontal filter on new lines from input if needed */ |
||||
src_y1 = src_y >> POS_FRAC_BITS; |
||||
while (last_src_y < src_y1) { |
||||
if (++ring_y >= LINE_BUF_HEIGHT + NB_TAPS) |
||||
ring_y = NB_TAPS; |
||||
last_src_y++; |
||||
/* handle limit conditions : replicate line (slightly
|
||||
inefficient because we filter multiple times) */ |
||||
y1 = last_src_y; |
||||
if (y1 < 0) { |
||||
y1 = 0; |
||||
} else if (y1 >= iheight) { |
||||
y1 = iheight - 1; |
||||
} |
||||
src_line = input + y1 * iwrap; |
||||
new_line = s->line_buf + ring_y * owidth; |
||||
/* apply filter and handle limit cases correctly */ |
||||
h_resample(new_line, owidth, |
||||
src_line, iwidth, - FCENTER * POS_FRAC, s->h_incr, |
||||
&s->h_filters[0][0]); |
||||
/* handle ring buffer wrapping */ |
||||
if (ring_y >= LINE_BUF_HEIGHT) { |
||||
memcpy(s->line_buf + (ring_y - LINE_BUF_HEIGHT) * owidth, |
||||
new_line, owidth); |
||||
} |
||||
} |
||||
/* apply vertical filter */ |
||||
phase_y = get_phase(src_y); |
||||
#if HAVE_MMX |
||||
/* desactivated MMX because loss of precision */ |
||||
if ((mm_flags & FF_MM_MMX) && NB_TAPS == 4 && 0) |
||||
v_resample4_mmx(output, owidth, |
||||
s->line_buf + (ring_y - NB_TAPS + 1) * owidth, owidth, |
||||
&s->v_filters[phase_y][0]); |
||||
else |
||||
#endif |
||||
#if HAVE_ALTIVEC |
||||
if ((mm_flags & FF_MM_ALTIVEC) && NB_TAPS == 4 && FILTER_BITS <= 6) |
||||
v_resample16_altivec(output, owidth, |
||||
s->line_buf + (ring_y - NB_TAPS + 1) * owidth, |
||||
owidth, &s->v_filters[phase_y][0]); |
||||
else |
||||
#endif |
||||
v_resample(output, owidth, |
||||
s->line_buf + (ring_y - NB_TAPS + 1) * owidth, owidth, |
||||
&s->v_filters[phase_y][0]); |
||||
|
||||
src_y += s->v_incr; |
||||
|
||||
output += owrap; |
||||
} |
||||
} |
||||
|
||||
ImgReSampleContext *img_resample_full_init(int owidth, int oheight, |
||||
int iwidth, int iheight, |
||||
int topBand, int bottomBand, |
||||
int leftBand, int rightBand, |
||||
int padtop, int padbottom, |
||||
int padleft, int padright) |
||||
{ |
||||
ImgReSampleContext *s; |
||||
|
||||
if (!owidth || !oheight || !iwidth || !iheight) |
||||
return NULL; |
||||
|
||||
s = av_mallocz(sizeof(ImgReSampleContext)); |
||||
if (!s) |
||||
return NULL; |
||||
if((unsigned)owidth >= UINT_MAX / (LINE_BUF_HEIGHT + NB_TAPS)) |
||||
goto fail; |
||||
s->line_buf = av_mallocz(owidth * (LINE_BUF_HEIGHT + NB_TAPS)); |
||||
if (!s->line_buf) |
||||
goto fail; |
||||
|
||||
s->owidth = owidth; |
||||
s->oheight = oheight; |
||||
s->iwidth = iwidth; |
||||
s->iheight = iheight; |
||||
|
||||
s->topBand = topBand; |
||||
s->bottomBand = bottomBand; |
||||
s->leftBand = leftBand; |
||||
s->rightBand = rightBand; |
||||
|
||||
s->padtop = padtop; |
||||
s->padbottom = padbottom; |
||||
s->padleft = padleft; |
||||
s->padright = padright; |
||||
|
||||
s->pad_owidth = owidth - (padleft + padright); |
||||
s->pad_oheight = oheight - (padtop + padbottom); |
||||
|
||||
s->h_incr = ((iwidth - leftBand - rightBand) * POS_FRAC) / s->pad_owidth; |
||||
s->v_incr = ((iheight - topBand - bottomBand) * POS_FRAC) / s->pad_oheight; |
||||
|
||||
av_build_filter(&s->h_filters[0][0], (float) s->pad_owidth / |
||||
(float) (iwidth - leftBand - rightBand), NB_TAPS, NB_PHASES, 1<<FILTER_BITS, 0); |
||||
av_build_filter(&s->v_filters[0][0], (float) s->pad_oheight / |
||||
(float) (iheight - topBand - bottomBand), NB_TAPS, NB_PHASES, 1<<FILTER_BITS, 0); |
||||
|
||||
return s; |
||||
fail: |
||||
av_free(s); |
||||
return NULL; |
||||
} |
||||
|
||||
ImgReSampleContext *img_resample_init(int owidth, int oheight, |
||||
int iwidth, int iheight) |
||||
{ |
||||
return img_resample_full_init(owidth, oheight, iwidth, iheight, |
||||
0, 0, 0, 0, 0, 0, 0, 0); |
||||
} |
||||
|
||||
void img_resample(ImgReSampleContext *s, |
||||
AVPicture *output, const AVPicture *input) |
||||
{ |
||||
int i, shift; |
||||
uint8_t* optr; |
||||
|
||||
for (i=0;i<3;i++) { |
||||
shift = (i == 0) ? 0 : 1; |
||||
|
||||
optr = output->data[i] + (((output->linesize[i] * |
||||
s->padtop) + s->padleft) >> shift); |
||||
|
||||
component_resample(s, optr, output->linesize[i], |
||||
s->pad_owidth >> shift, s->pad_oheight >> shift, |
||||
input->data[i] + (input->linesize[i] * |
||||
(s->topBand >> shift)) + (s->leftBand >> shift), |
||||
input->linesize[i], ((s->iwidth - s->leftBand - |
||||
s->rightBand) >> shift), |
||||
(s->iheight - s->topBand - s->bottomBand) >> shift); |
||||
} |
||||
} |
||||
|
||||
void img_resample_close(ImgReSampleContext *s) |
||||
{ |
||||
av_free(s->line_buf); |
||||
av_free(s); |
||||
} |
||||
|
||||
static const char *context_to_name(void* ptr) |
||||
{ |
||||
return "imgconvert"; |
||||
} |
||||
|
||||
static const AVClass context_class = { "imgresample", context_to_name, NULL }; |
||||
|
||||
struct SwsContext *sws_getContext(int srcW, int srcH, int srcFormat, |
||||
int dstW, int dstH, int dstFormat, |
||||
int flags, SwsFilter *srcFilter, |
||||
SwsFilter *dstFilter, double *param) |
||||
{ |
||||
struct SwsContext *ctx; |
||||
|
||||
ctx = av_malloc(sizeof(struct SwsContext)); |
||||
if (!ctx) { |
||||
av_log(NULL, AV_LOG_ERROR, "Cannot allocate a resampling context!\n"); |
||||
|
||||
return NULL; |
||||
} |
||||
ctx->av_class = &context_class; |
||||
|
||||
if ((srcH != dstH) || (srcW != dstW)) { |
||||
if ((srcFormat != PIX_FMT_YUV420P) || (dstFormat != PIX_FMT_YUV420P)) { |
||||
av_log(ctx, AV_LOG_INFO, "PIX_FMT_YUV420P will be used as an intermediate format for rescaling\n"); |
||||
} |
||||
ctx->resampling_ctx = img_resample_init(dstW, dstH, srcW, srcH); |
||||
} else { |
||||
ctx->resampling_ctx = av_malloc(sizeof(ImgReSampleContext)); |
||||
ctx->resampling_ctx->iheight = srcH; |
||||
ctx->resampling_ctx->iwidth = srcW; |
||||
ctx->resampling_ctx->oheight = dstH; |
||||
ctx->resampling_ctx->owidth = dstW; |
||||
} |
||||
ctx->src_pix_fmt = srcFormat; |
||||
ctx->dst_pix_fmt = dstFormat; |
||||
|
||||
return ctx; |
||||
} |
||||
|
||||
void sws_freeContext(struct SwsContext *ctx) |
||||
{ |
||||
if (!ctx) |
||||
return; |
||||
if ((ctx->resampling_ctx->iwidth != ctx->resampling_ctx->owidth) || |
||||
(ctx->resampling_ctx->iheight != ctx->resampling_ctx->oheight)) { |
||||
img_resample_close(ctx->resampling_ctx); |
||||
} else { |
||||
av_free(ctx->resampling_ctx); |
||||
} |
||||
av_free(ctx); |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* Checks if context is valid or reallocs a new one instead. |
||||
* If context is NULL, just calls sws_getContext() to get a new one. |
||||
* Otherwise, checks if the parameters are the same already saved in context. |
||||
* If that is the case, returns the current context. |
||||
* Otherwise, frees context and gets a new one. |
||||
* |
||||
* Be warned that srcFilter, dstFilter are not checked, they are |
||||
* assumed to remain valid. |
||||
*/ |
||||
struct SwsContext *sws_getCachedContext(struct SwsContext *ctx, |
||||
int srcW, int srcH, int srcFormat, |
||||
int dstW, int dstH, int dstFormat, int flags, |
||||
SwsFilter *srcFilter, SwsFilter *dstFilter, double *param) |
||||
{ |
||||
if (ctx != NULL) { |
||||
if ((ctx->resampling_ctx->iwidth != srcW) || |
||||
(ctx->resampling_ctx->iheight != srcH) || |
||||
(ctx->src_pix_fmt != srcFormat) || |
||||
(ctx->resampling_ctx->owidth != dstW) || |
||||
(ctx->resampling_ctx->oheight != dstH) || |
||||
(ctx->dst_pix_fmt != dstFormat)) |
||||
{ |
||||
sws_freeContext(ctx); |
||||
ctx = NULL; |
||||
} |
||||
} |
||||
if (ctx == NULL) { |
||||
return sws_getContext(srcW, srcH, srcFormat, |
||||
dstW, dstH, dstFormat, flags, |
||||
srcFilter, dstFilter, param); |
||||
} |
||||
return ctx; |
||||
} |
||||
|
||||
int sws_scale(struct SwsContext *ctx, uint8_t* src[], int srcStride[], |
||||
int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]) |
||||
{ |
||||
AVPicture src_pict, dst_pict; |
||||
int i, res = 0; |
||||
AVPicture picture_format_temp; |
||||
AVPicture picture_resample_temp, *formatted_picture, *resampled_picture; |
||||
uint8_t *buf1 = NULL, *buf2 = NULL; |
||||
enum PixelFormat current_pix_fmt; |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
src_pict.data[i] = src[i]; |
||||
src_pict.linesize[i] = srcStride[i]; |
||||
dst_pict.data[i] = dst[i]; |
||||
dst_pict.linesize[i] = dstStride[i]; |
||||
} |
||||
if ((ctx->resampling_ctx->iwidth != ctx->resampling_ctx->owidth) || |
||||
(ctx->resampling_ctx->iheight != ctx->resampling_ctx->oheight)) { |
||||
/* We have to rescale the picture, but only YUV420P rescaling is supported... */ |
||||
|
||||
if (ctx->src_pix_fmt != PIX_FMT_YUV420P) { |
||||
int size; |
||||
|
||||
/* create temporary picture for rescaling input*/ |
||||
size = avpicture_get_size(PIX_FMT_YUV420P, ctx->resampling_ctx->iwidth, ctx->resampling_ctx->iheight); |
||||
buf1 = av_malloc(size); |
||||
if (!buf1) { |
||||
res = -1; |
||||
goto the_end; |
||||
} |
||||
formatted_picture = &picture_format_temp; |
||||
avpicture_fill((AVPicture*)formatted_picture, buf1, |
||||
PIX_FMT_YUV420P, ctx->resampling_ctx->iwidth, ctx->resampling_ctx->iheight); |
||||
|
||||
if (img_convert((AVPicture*)formatted_picture, PIX_FMT_YUV420P, |
||||
&src_pict, ctx->src_pix_fmt, |
||||
ctx->resampling_ctx->iwidth, ctx->resampling_ctx->iheight) < 0) { |
||||
|
||||
av_log(ctx, AV_LOG_ERROR, "pixel format conversion not handled\n"); |
||||
res = -1; |
||||
goto the_end; |
||||
} |
||||
} else { |
||||
formatted_picture = &src_pict; |
||||
} |
||||
|
||||
if (ctx->dst_pix_fmt != PIX_FMT_YUV420P) { |
||||
int size; |
||||
|
||||
/* create temporary picture for rescaling output*/ |
||||
size = avpicture_get_size(PIX_FMT_YUV420P, ctx->resampling_ctx->owidth, ctx->resampling_ctx->oheight); |
||||
buf2 = av_malloc(size); |
||||
if (!buf2) { |
||||
res = -1; |
||||
goto the_end; |
||||
} |
||||
resampled_picture = &picture_resample_temp; |
||||
avpicture_fill((AVPicture*)resampled_picture, buf2, |
||||
PIX_FMT_YUV420P, ctx->resampling_ctx->owidth, ctx->resampling_ctx->oheight); |
||||
|
||||
} else { |
||||
resampled_picture = &dst_pict; |
||||
} |
||||
|
||||
/* ...and finally rescale!!! */ |
||||
img_resample(ctx->resampling_ctx, resampled_picture, formatted_picture); |
||||
current_pix_fmt = PIX_FMT_YUV420P; |
||||
} else { |
||||
resampled_picture = &src_pict; |
||||
current_pix_fmt = ctx->src_pix_fmt; |
||||
} |
||||
|
||||
if (current_pix_fmt != ctx->dst_pix_fmt) { |
||||
if (img_convert(&dst_pict, ctx->dst_pix_fmt, |
||||
resampled_picture, current_pix_fmt, |
||||
ctx->resampling_ctx->owidth, ctx->resampling_ctx->oheight) < 0) { |
||||
|
||||
av_log(ctx, AV_LOG_ERROR, "pixel format conversion not handled\n"); |
||||
|
||||
res = -1; |
||||
goto the_end; |
||||
} |
||||
} else if (resampled_picture != &dst_pict) { |
||||
av_picture_copy(&dst_pict, resampled_picture, current_pix_fmt, |
||||
ctx->resampling_ctx->owidth, ctx->resampling_ctx->oheight); |
||||
} |
||||
|
||||
the_end: |
||||
av_free(buf1); |
||||
av_free(buf2); |
||||
return res; |
||||
} |
||||
|
||||
|
||||
#ifdef TEST |
||||
#include <stdio.h> |
||||
#undef exit |
||||
|
||||
/* input */ |
||||
#define XSIZE 256 |
||||
#define YSIZE 256 |
||||
uint8_t img[XSIZE * YSIZE]; |
||||
|
||||
/* output */ |
||||
#define XSIZE1 512 |
||||
#define YSIZE1 512 |
||||
uint8_t img1[XSIZE1 * YSIZE1]; |
||||
uint8_t img2[XSIZE1 * YSIZE1]; |
||||
|
||||
void save_pgm(const char *filename, uint8_t *img, int xsize, int ysize) |
||||
{ |
||||
#undef fprintf |
||||
FILE *f; |
||||
f=fopen(filename,"w"); |
||||
fprintf(f,"P5\n%d %d\n%d\n", xsize, ysize, 255); |
||||
fwrite(img,1, xsize * ysize,f); |
||||
fclose(f); |
||||
#define fprintf please_use_av_log |
||||
} |
||||
|
||||
static void dump_filter(int16_t *filter) |
||||
{ |
||||
int i, ph; |
||||
|
||||
for(ph=0;ph<NB_PHASES;ph++) { |
||||
av_log(NULL, AV_LOG_INFO, "%2d: ", ph); |
||||
for(i=0;i<NB_TAPS;i++) { |
||||
av_log(NULL, AV_LOG_INFO, " %5.2f", filter[ph * NB_TAPS + i] / 256.0); |
||||
} |
||||
av_log(NULL, AV_LOG_INFO, "\n"); |
||||
} |
||||
} |
||||
|
||||
#if HAVE_MMX |
||||
int mm_flags; |
||||
#endif |
||||
|
||||
int main(int argc, char **argv) |
||||
{ |
||||
int x, y, v, i, xsize, ysize; |
||||
ImgReSampleContext *s; |
||||
float fact, factors[] = { 1/2.0, 3.0/4.0, 1.0, 4.0/3.0, 16.0/9.0, 2.0 }; |
||||
char buf[256]; |
||||
|
||||
/* build test image */ |
||||
for(y=0;y<YSIZE;y++) { |
||||
for(x=0;x<XSIZE;x++) { |
||||
if (x < XSIZE/2 && y < YSIZE/2) { |
||||
if (x < XSIZE/4 && y < YSIZE/4) { |
||||
if ((x % 10) <= 6 && |
||||
(y % 10) <= 6) |
||||
v = 0xff; |
||||
else |
||||
v = 0x00; |
||||
} else if (x < XSIZE/4) { |
||||
if (x & 1) |
||||
v = 0xff; |
||||
else |
||||
v = 0; |
||||
} else if (y < XSIZE/4) { |
||||
if (y & 1) |
||||
v = 0xff; |
||||
else |
||||
v = 0; |
||||
} else { |
||||
if (y < YSIZE*3/8) { |
||||
if ((y+x) & 1) |
||||
v = 0xff; |
||||
else |
||||
v = 0; |
||||
} else { |
||||
if (((x+3) % 4) <= 1 && |
||||
((y+3) % 4) <= 1) |
||||
v = 0xff; |
||||
else |
||||
v = 0x00; |
||||
} |
||||
} |
||||
} else if (x < XSIZE/2) { |
||||
v = ((x - (XSIZE/2)) * 255) / (XSIZE/2); |
||||
} else if (y < XSIZE/2) { |
||||
v = ((y - (XSIZE/2)) * 255) / (XSIZE/2); |
||||
} else { |
||||
v = ((x + y - XSIZE) * 255) / XSIZE; |
||||
} |
||||
img[(YSIZE - y) * XSIZE + (XSIZE - x)] = v; |
||||
} |
||||
} |
||||
save_pgm("/tmp/in.pgm", img, XSIZE, YSIZE); |
||||
for(i=0;i<FF_ARRAY_ELEMS(factors);i++) { |
||||
fact = factors[i]; |
||||
xsize = (int)(XSIZE * fact); |
||||
ysize = (int)((YSIZE - 100) * fact); |
||||
s = img_resample_full_init(xsize, ysize, XSIZE, YSIZE, 50 ,50, 0, 0, 0, 0, 0, 0); |
||||
av_log(NULL, AV_LOG_INFO, "Factor=%0.2f\n", fact); |
||||
dump_filter(&s->h_filters[0][0]); |
||||
component_resample(s, img1, xsize, xsize, ysize, |
||||
img + 50 * XSIZE, XSIZE, XSIZE, YSIZE - 100); |
||||
img_resample_close(s); |
||||
|
||||
snprintf(buf, sizeof(buf), "/tmp/out%d.pgm", i); |
||||
save_pgm(buf, img1, xsize, ysize); |
||||
} |
||||
|
||||
/* mmx test */ |
||||
#if HAVE_MMX |
||||
av_log(NULL, AV_LOG_INFO, "MMX test\n"); |
||||
fact = 0.72; |
||||
xsize = (int)(XSIZE * fact); |
||||
ysize = (int)(YSIZE * fact); |
||||
mm_flags = FF_MM_MMX; |
||||
s = img_resample_init(xsize, ysize, XSIZE, YSIZE); |
||||
component_resample(s, img1, xsize, xsize, ysize, |
||||
img, XSIZE, XSIZE, YSIZE); |
||||
|
||||
mm_flags = 0; |
||||
s = img_resample_init(xsize, ysize, XSIZE, YSIZE); |
||||
component_resample(s, img2, xsize, xsize, ysize, |
||||
img, XSIZE, XSIZE, YSIZE); |
||||
if (memcmp(img1, img2, xsize * ysize) != 0) { |
||||
av_log(NULL, AV_LOG_ERROR, "mmx error\n"); |
||||
exit(1); |
||||
} |
||||
av_log(NULL, AV_LOG_INFO, "MMX OK\n"); |
||||
#endif /* HAVE_MMX */ |
||||
return 0; |
||||
} |
||||
|
||||
#endif /* TEST */ |
||||
@ -1,142 +0,0 @@ |
||||
/*
|
||||
* High quality image resampling with polyphase filters |
||||
* Copyright (c) 2001 Fabrice Bellard |
||||
* |
||||
* 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.1 of the License, or (at your option) any later version. |
||||
* |
||||
* 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 FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
/**
|
||||
* @file libavcodec/ppc/imgresample_altivec.c |
||||
* High quality image resampling with polyphase filters - AltiVec bits |
||||
*/ |
||||
|
||||
#include "util_altivec.h" |
||||
#define FILTER_BITS 8 |
||||
|
||||
typedef union { |
||||
vector signed short v; |
||||
signed short s[8]; |
||||
} vec_ss; |
||||
|
||||
void v_resample16_altivec(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int wrap, int16_t *filter) |
||||
{ |
||||
int sum, i; |
||||
const uint8_t *s; |
||||
vector unsigned char *tv, tmp, dstv, zero; |
||||
vec_ss srchv[4], srclv[4], fv[4]; |
||||
vector signed short zeros, sumhv, sumlv; |
||||
s = src; |
||||
|
||||
for(i=0;i<4;i++) { |
||||
/*
|
||||
The vec_madds later on does an implicit >>15 on the result. |
||||
Since FILTER_BITS is 8, and we have 15 bits of magnitude in |
||||
a signed short, we have just enough bits to pre-shift our |
||||
filter constants <<7 to compensate for vec_madds. |
||||
*/ |
||||
fv[i].s[0] = filter[i] << (15-FILTER_BITS); |
||||
fv[i].v = vec_splat(fv[i].v, 0); |
||||
} |
||||
|
||||
zero = vec_splat_u8(0); |
||||
zeros = vec_splat_s16(0); |
||||
|
||||
|
||||
/*
|
||||
When we're resampling, we'd ideally like both our input buffers, |
||||
and output buffers to be 16-byte aligned, so we can do both aligned |
||||
reads and writes. Sadly we can't always have this at the moment, so |
||||
we opt for aligned writes, as unaligned writes have a huge overhead. |
||||
To do this, do enough scalar resamples to get dst 16-byte aligned. |
||||
*/ |
||||
i = (-(int)dst) & 0xf; |
||||
while(i>0) { |
||||
sum = s[0 * wrap] * filter[0] + |
||||
s[1 * wrap] * filter[1] + |
||||
s[2 * wrap] * filter[2] + |
||||
s[3 * wrap] * filter[3]; |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum<0) sum = 0; else if (sum>255) sum=255; |
||||
dst[0] = sum; |
||||
dst++; |
||||
s++; |
||||
dst_width--; |
||||
i--; |
||||
} |
||||
|
||||
/* Do our altivec resampling on 16 pixels at once. */ |
||||
while(dst_width>=16) { |
||||
/* Read 16 (potentially unaligned) bytes from each of
|
||||
4 lines into 4 vectors, and split them into shorts. |
||||
Interleave the multipy/accumulate for the resample |
||||
filter with the loads to hide the 3 cycle latency |
||||
the vec_madds have. */ |
||||
tv = (vector unsigned char *) &s[0 * wrap]; |
||||
tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[i * wrap])); |
||||
srchv[0].v = (vector signed short) vec_mergeh(zero, tmp); |
||||
srclv[0].v = (vector signed short) vec_mergel(zero, tmp); |
||||
sumhv = vec_madds(srchv[0].v, fv[0].v, zeros); |
||||
sumlv = vec_madds(srclv[0].v, fv[0].v, zeros); |
||||
|
||||
tv = (vector unsigned char *) &s[1 * wrap]; |
||||
tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[1 * wrap])); |
||||
srchv[1].v = (vector signed short) vec_mergeh(zero, tmp); |
||||
srclv[1].v = (vector signed short) vec_mergel(zero, tmp); |
||||
sumhv = vec_madds(srchv[1].v, fv[1].v, sumhv); |
||||
sumlv = vec_madds(srclv[1].v, fv[1].v, sumlv); |
||||
|
||||
tv = (vector unsigned char *) &s[2 * wrap]; |
||||
tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[2 * wrap])); |
||||
srchv[2].v = (vector signed short) vec_mergeh(zero, tmp); |
||||
srclv[2].v = (vector signed short) vec_mergel(zero, tmp); |
||||
sumhv = vec_madds(srchv[2].v, fv[2].v, sumhv); |
||||
sumlv = vec_madds(srclv[2].v, fv[2].v, sumlv); |
||||
|
||||
tv = (vector unsigned char *) &s[3 * wrap]; |
||||
tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[3 * wrap])); |
||||
srchv[3].v = (vector signed short) vec_mergeh(zero, tmp); |
||||
srclv[3].v = (vector signed short) vec_mergel(zero, tmp); |
||||
sumhv = vec_madds(srchv[3].v, fv[3].v, sumhv); |
||||
sumlv = vec_madds(srclv[3].v, fv[3].v, sumlv); |
||||
|
||||
/* Pack the results into our destination vector,
|
||||
and do an aligned write of that back to memory. */ |
||||
dstv = vec_packsu(sumhv, sumlv) ; |
||||
vec_st(dstv, 0, (vector unsigned char *) dst); |
||||
|
||||
dst+=16; |
||||
s+=16; |
||||
dst_width-=16; |
||||
} |
||||
|
||||
/* If there are any leftover pixels, resample them
|
||||
with the slow scalar method. */ |
||||
while(dst_width>0) { |
||||
sum = s[0 * wrap] * filter[0] + |
||||
s[1 * wrap] * filter[1] + |
||||
s[2 * wrap] * filter[2] + |
||||
s[3 * wrap] * filter[3]; |
||||
sum = sum >> FILTER_BITS; |
||||
if (sum<0) sum = 0; else if (sum>255) sum=255; |
||||
dst[0] = sum; |
||||
dst++; |
||||
s++; |
||||
dst_width--; |
||||
} |
||||
} |
||||
|
||||
@ -1,26 +0,0 @@ |
||||
/*
|
||||
* 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.1 of the License, or (at your option) any later version. |
||||
* |
||||
* 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 FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_PPC_IMGRESAMPLE_ALTIVEC_H |
||||
#define AVCODEC_PPC_IMGRESAMPLE_ALTIVEC_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
void v_resample16_altivec(uint8_t *dst, int dst_width, const uint8_t *src, |
||||
int wrap, int16_t *filter); |
||||
#endif /* AVCODEC_PPC_IMGRESAMPLE_ALTIVEC_H */ |
||||
Loading…
Reference in new issue