2002-01-21 20:32:31 +02:00
|
|
|
/*
|
2011-11-18 23:44:26 +03:00
|
|
|
* Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
|
2006-10-07 18:33:14 +03:00
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
2010-03-27 13:31:02 +02:00
|
|
|
* 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.
|
2006-10-07 18:33:14 +03:00
|
|
|
*
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2010-03-27 13:31:02 +02:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
2006-10-07 18:33:14 +03:00
|
|
|
*
|
2010-03-27 13:31:02 +02:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2007-07-05 13:18:58 +03:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2006-10-07 18:33:14 +03:00
|
|
|
*/
|
2001-10-19 01:27:13 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
#include <assert.h>
|
2001-10-17 05:30:39 +03:00
|
|
|
#include <inttypes.h>
|
2001-12-02 22:03:26 +02:00
|
|
|
#include <math.h>
|
2001-12-06 02:10:42 +02:00
|
|
|
#include <stdio.h>
|
2012-04-01 11:34:10 +03:00
|
|
|
#include <string.h>
|
|
|
|
|
2011-05-24 23:59:11 +03:00
|
|
|
#include "libavutil/avassert.h"
|
2009-08-30 02:02:01 +03:00
|
|
|
#include "libavutil/avutil.h"
|
2008-05-09 15:00:25 +03:00
|
|
|
#include "libavutil/bswap.h"
|
2012-04-01 11:34:10 +03:00
|
|
|
#include "libavutil/cpu.h"
|
|
|
|
#include "libavutil/intreadwrite.h"
|
|
|
|
#include "libavutil/mathematics.h"
|
2009-11-26 23:08:45 +02:00
|
|
|
#include "libavutil/pixdesc.h"
|
2012-04-01 11:34:10 +03:00
|
|
|
#include "config.h"
|
|
|
|
#include "rgb2rgb.h"
|
|
|
|
#include "swscale_internal.h"
|
|
|
|
#include "swscale.h"
|
2002-06-22 11:49:45 +03:00
|
|
|
|
2011-07-05 22:49:11 +03:00
|
|
|
DECLARE_ALIGNED(8, const uint8_t, dither_8x8_128)[8][8] = {
|
2012-04-01 11:34:10 +03:00
|
|
|
{ 36, 68, 60, 92, 34, 66, 58, 90, },
|
|
|
|
{ 100, 4, 124, 28, 98, 2, 122, 26, },
|
|
|
|
{ 52, 84, 44, 76, 50, 82, 42, 74, },
|
|
|
|
{ 116, 20, 108, 12, 114, 18, 106, 10, },
|
|
|
|
{ 32, 64, 56, 88, 38, 70, 62, 94, },
|
|
|
|
{ 96, 0, 120, 24, 102, 6, 126, 30, },
|
|
|
|
{ 48, 80, 40, 72, 54, 86, 46, 78, },
|
|
|
|
{ 112, 16, 104, 8, 118, 22, 110, 14, },
|
2011-07-05 22:49:11 +03:00
|
|
|
};
|
2002-01-21 17:22:28 +02:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
DECLARE_ALIGNED(8, const uint8_t, ff_sws_pb_64)[8] = {
|
|
|
|
64, 64, 64, 64, 64, 64, 64, 64
|
2011-07-05 22:49:11 +03:00
|
|
|
};
|
2012-02-08 04:59:09 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static av_always_inline void fillPlane(uint8_t *plane, int stride, int width,
|
|
|
|
int height, int y, uint8_t val)
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2009-03-17 21:53:36 +02:00
|
|
|
int i;
|
2012-04-01 11:34:10 +03:00
|
|
|
uint8_t *ptr = plane + stride * y;
|
|
|
|
for (i = 0; i < height; i++) {
|
2009-03-17 21:53:36 +02:00
|
|
|
memset(ptr, val, width);
|
|
|
|
ptr += stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static void hScale16To19_c(SwsContext *c, int16_t *_dst, int dstW,
|
|
|
|
const uint8_t *_src, const int16_t *filter,
|
2012-03-05 23:26:42 +03:00
|
|
|
const int32_t *filterPos, int filterSize)
|
2011-06-29 19:39:43 +03:00
|
|
|
{
|
|
|
|
int i;
|
2012-04-01 11:34:10 +03:00
|
|
|
int32_t *dst = (int32_t *) _dst;
|
2011-06-29 19:39:43 +03:00
|
|
|
const uint16_t *src = (const uint16_t *) _src;
|
2012-04-01 11:34:10 +03:00
|
|
|
int bits = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
|
|
|
|
int sh = bits - 4;
|
2011-06-29 19:39:43 +03:00
|
|
|
|
2011-07-03 03:08:45 +03:00
|
|
|
if((isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8) && av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1<15)
|
|
|
|
sh= 9;
|
|
|
|
|
2011-06-29 19:39:43 +03:00
|
|
|
for (i = 0; i < dstW; i++) {
|
|
|
|
int j;
|
|
|
|
int srcPos = filterPos[i];
|
2012-04-01 11:34:10 +03:00
|
|
|
int val = 0;
|
2011-06-29 19:39:43 +03:00
|
|
|
|
|
|
|
for (j = 0; j < filterSize; j++) {
|
|
|
|
val += src[srcPos + j] * filter[filterSize * i + j];
|
|
|
|
}
|
|
|
|
// filter=14 bit, input=16 bit, output=30 bit, >> 11 makes 19 bit
|
2011-07-01 03:35:13 +03:00
|
|
|
dst[i] = FFMIN(val >> sh, (1 << 19) - 1);
|
2011-06-29 19:39:43 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static void hScale16To15_c(SwsContext *c, int16_t *dst, int dstW,
|
|
|
|
const uint8_t *_src, const int16_t *filter,
|
2012-03-05 23:26:42 +03:00
|
|
|
const int32_t *filterPos, int filterSize)
|
2011-08-03 01:42:35 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const uint16_t *src = (const uint16_t *) _src;
|
2012-04-01 11:34:10 +03:00
|
|
|
int sh = av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
|
2011-08-03 01:42:35 +03:00
|
|
|
|
2011-08-14 20:05:03 +03:00
|
|
|
if(sh<15)
|
|
|
|
sh= isAnyRGB(c->srcFormat) || c->srcFormat==PIX_FMT_PAL8 ? 13 : av_pix_fmt_descriptors[c->srcFormat].comp[0].depth_minus1;
|
|
|
|
|
2011-08-03 01:42:35 +03:00
|
|
|
for (i = 0; i < dstW; i++) {
|
|
|
|
int j;
|
|
|
|
int srcPos = filterPos[i];
|
2012-04-01 11:34:10 +03:00
|
|
|
int val = 0;
|
2011-08-03 01:42:35 +03:00
|
|
|
|
|
|
|
for (j = 0; j < filterSize; j++) {
|
|
|
|
val += src[srcPos + j] * filter[filterSize * i + j];
|
|
|
|
}
|
|
|
|
// filter=14 bit, input=16 bit, output=30 bit, >> 15 makes 15 bit
|
|
|
|
dst[i] = FFMIN(val >> sh, (1 << 15) - 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-03 08:34:12 +03:00
|
|
|
// bilinear / bicubic scaling
|
2012-04-01 11:34:10 +03:00
|
|
|
static void hScale8To15_c(SwsContext *c, int16_t *dst, int dstW,
|
|
|
|
const uint8_t *src, const int16_t *filter,
|
|
|
|
const int32_t *filterPos, int filterSize)
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2008-10-08 20:46:22 +03:00
|
|
|
int i;
|
2012-04-01 11:34:10 +03:00
|
|
|
for (i = 0; i < dstW; i++) {
|
2011-06-03 08:34:12 +03:00
|
|
|
int j;
|
2012-04-01 11:34:10 +03:00
|
|
|
int srcPos = filterPos[i];
|
|
|
|
int val = 0;
|
|
|
|
for (j = 0; j < filterSize; j++) {
|
|
|
|
val += ((int)src[srcPos + j]) * filter[filterSize * i + j];
|
2010-01-18 01:02:20 +02:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
dst[i] = FFMIN(val >> 7, (1 << 15) - 1); // the cubic equation does overflow ...
|
2010-01-18 01:00:01 +02:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2008-10-08 20:46:22 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static void hScale8To19_c(SwsContext *c, int16_t *_dst, int dstW,
|
|
|
|
const uint8_t *src, const int16_t *filter,
|
|
|
|
const int32_t *filterPos, int filterSize)
|
2011-08-03 01:42:35 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dst = (int32_t *) _dst;
|
2012-04-01 11:34:10 +03:00
|
|
|
for (i = 0; i < dstW; i++) {
|
2011-08-03 01:42:35 +03:00
|
|
|
int j;
|
2012-04-01 11:34:10 +03:00
|
|
|
int srcPos = filterPos[i];
|
|
|
|
int val = 0;
|
|
|
|
for (j = 0; j < filterSize; j++) {
|
|
|
|
val += ((int)src[srcPos + j]) * filter[filterSize * i + j];
|
2011-08-03 01:42:35 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
dst[i] = FFMIN(val >> 3, (1 << 19) - 1); // the cubic equation does overflow ...
|
2011-08-03 01:42:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
// FIXME all pal and rgb srcFormats could do this convertion as well
|
|
|
|
// FIXME all scalers more complex than bilinear could do half of this transform
|
2011-06-04 07:31:35 +03:00
|
|
|
static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width)
|
2011-06-03 08:34:12 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 11:34:10 +03:00
|
|
|
dstU[i] = (FFMIN(dstU[i], 30775) * 4663 - 9289992) >> 12; // -264
|
|
|
|
dstV[i] = (FFMIN(dstV[i], 30775) * 4663 - 9289992) >> 12; // -264
|
2007-04-29 16:39:27 +03:00
|
|
|
}
|
2002-06-22 11:49:45 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-04 07:31:35 +03:00
|
|
|
static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width)
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2011-06-03 08:34:12 +03:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 11:34:10 +03:00
|
|
|
dstU[i] = (dstU[i] * 1799 + 4081085) >> 11; // 1469
|
|
|
|
dstV[i] = (dstV[i] * 1799 + 4081085) >> 11; // 1469
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2002-02-10 02:43:31 +02:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-04 07:31:35 +03:00
|
|
|
static void lumRangeToJpeg_c(int16_t *dst, int width)
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2011-06-03 08:34:12 +03:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++)
|
2012-04-01 11:34:10 +03:00
|
|
|
dst[i] = (FFMIN(dst[i], 30189) * 19077 - 39057361) >> 14;
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-04 07:31:35 +03:00
|
|
|
static void lumRangeFromJpeg_c(int16_t *dst, int width)
|
2011-06-03 08:34:12 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++)
|
2012-04-01 11:34:10 +03:00
|
|
|
dst[i] = (dst[i] * 14071 + 33561947) >> 14;
|
2002-06-28 02:48:53 +03:00
|
|
|
}
|
|
|
|
|
2011-06-29 19:39:43 +03:00
|
|
|
static void chrRangeToJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dstU = (int32_t *) _dstU;
|
|
|
|
int32_t *dstV = (int32_t *) _dstV;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 11:34:10 +03:00
|
|
|
dstU[i] = (FFMIN(dstU[i], 30775 << 4) * 4663 - (9289992 << 4)) >> 12; // -264
|
|
|
|
dstV[i] = (FFMIN(dstV[i], 30775 << 4) * 4663 - (9289992 << 4)) >> 12; // -264
|
2011-06-29 19:39:43 +03:00
|
|
|
}
|
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-29 19:39:43 +03:00
|
|
|
static void chrRangeFromJpeg16_c(int16_t *_dstU, int16_t *_dstV, int width)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dstU = (int32_t *) _dstU;
|
|
|
|
int32_t *dstV = (int32_t *) _dstV;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 11:34:10 +03:00
|
|
|
dstU[i] = (dstU[i] * 1799 + (4081085 << 4)) >> 11; // 1469
|
|
|
|
dstV[i] = (dstV[i] * 1799 + (4081085 << 4)) >> 11; // 1469
|
2011-06-29 19:39:43 +03:00
|
|
|
}
|
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-29 19:39:43 +03:00
|
|
|
static void lumRangeToJpeg16_c(int16_t *_dst, int width)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dst = (int32_t *) _dst;
|
|
|
|
for (i = 0; i < width; i++)
|
2012-04-01 11:34:10 +03:00
|
|
|
dst[i] = (FFMIN(dst[i], 30189 << 4) * 4769 - (39057361 << 2)) >> 12;
|
2011-06-29 19:39:43 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
|
2011-06-29 19:39:43 +03:00
|
|
|
static void lumRangeFromJpeg16_c(int16_t *_dst, int width)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dst = (int32_t *) _dst;
|
|
|
|
for (i = 0; i < width; i++)
|
2011-07-01 06:28:13 +03:00
|
|
|
dst[i] = (dst[i]*(14071/4) + (33561947<<4)/4)>>12;
|
2011-06-29 19:39:43 +03:00
|
|
|
}
|
|
|
|
|
2011-06-03 08:34:13 +03:00
|
|
|
static void hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
|
|
|
|
const uint8_t *src, int srcW, int xInc)
|
2008-07-06 06:27:31 +03:00
|
|
|
{
|
2011-06-03 08:34:12 +03:00
|
|
|
int i;
|
2012-04-01 11:34:10 +03:00
|
|
|
unsigned int xpos = 0;
|
|
|
|
for (i = 0; i < dstWidth; i++) {
|
|
|
|
register unsigned int xx = xpos >> 16;
|
|
|
|
register unsigned int xalpha = (xpos & 0xFFFF) >> 9;
|
|
|
|
dst[i] = (src[xx] << 7) + (src[xx + 1] - src[xx]) * xalpha;
|
|
|
|
xpos += xInc;
|
2008-07-06 06:27:31 +03:00
|
|
|
}
|
2011-06-04 07:31:35 +03:00
|
|
|
for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)
|
|
|
|
dst[i] = src[srcW-1]*128;
|
2008-07-06 06:26:32 +03:00
|
|
|
}
|
2008-07-06 06:27:31 +03:00
|
|
|
|
2011-06-03 08:34:13 +03:00
|
|
|
// *** horizontal scale Y line to temp buffer
|
2011-06-29 19:39:43 +03:00
|
|
|
static av_always_inline void hyscale(SwsContext *c, int16_t *dst, int dstWidth,
|
2012-04-01 11:34:10 +03:00
|
|
|
const uint8_t *src_in[4],
|
|
|
|
int srcW, int xInc,
|
2011-06-08 19:31:11 +03:00
|
|
|
const int16_t *hLumFilter,
|
2012-04-01 11:34:10 +03:00
|
|
|
const int32_t *hLumFilterPos,
|
|
|
|
int hLumFilterSize,
|
2011-06-08 19:31:11 +03:00
|
|
|
uint8_t *formatConvBuffer,
|
|
|
|
uint32_t *pal, int isAlpha)
|
2011-06-03 08:34:12 +03:00
|
|
|
{
|
2012-04-13 22:21:15 +03:00
|
|
|
void (*toYV12)(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, int, uint32_t *) =
|
2012-04-01 11:34:10 +03:00
|
|
|
isAlpha ? c->alpToYV12 : c->lumToYV12;
|
2011-06-04 07:31:35 +03:00
|
|
|
void (*convertRange)(int16_t *, int) = isAlpha ? NULL : c->lumConvertRange;
|
2011-11-24 21:40:05 +03:00
|
|
|
const uint8_t *src = src_in[isAlpha ? 3 : 0];
|
2011-05-09 22:38:46 +03:00
|
|
|
|
2011-06-03 08:34:12 +03:00
|
|
|
if (toYV12) {
|
2011-11-25 03:38:21 +03:00
|
|
|
toYV12(formatConvBuffer, src, src_in[1], src_in[2], srcW, pal);
|
2012-04-01 11:34:10 +03:00
|
|
|
src = formatConvBuffer;
|
2011-11-24 21:40:05 +03:00
|
|
|
} else if (c->readLumPlanar && !isAlpha) {
|
|
|
|
c->readLumPlanar(formatConvBuffer, src_in, srcW);
|
|
|
|
src = formatConvBuffer;
|
2011-05-13 05:40:40 +03:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2011-09-14 01:32:18 +03:00
|
|
|
if (!c->hyscale_fast) {
|
2012-04-01 11:34:10 +03:00
|
|
|
c->hyScale(c, dst, dstWidth, src, hLumFilter,
|
|
|
|
hLumFilterPos, hLumFilterSize);
|
2011-06-03 08:34:12 +03:00
|
|
|
} else { // fast bilinear upscale / crap downscale
|
|
|
|
c->hyscale_fast(c, dst, dstWidth, src, srcW, xInc);
|
2008-07-06 06:27:31 +03:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
if (convertRange)
|
|
|
|
convertRange(dst, dstWidth);
|
2002-02-06 22:52:14 +02:00
|
|
|
}
|
2002-01-20 07:30:23 +02:00
|
|
|
|
2011-06-03 08:34:13 +03:00
|
|
|
static void hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
|
|
|
|
int dstWidth, const uint8_t *src1,
|
|
|
|
const uint8_t *src2, int srcW, int xInc)
|
2010-01-24 04:08:22 +02:00
|
|
|
{
|
2011-06-03 08:34:12 +03:00
|
|
|
int i;
|
2012-04-01 11:34:10 +03:00
|
|
|
unsigned int xpos = 0;
|
|
|
|
for (i = 0; i < dstWidth; i++) {
|
|
|
|
register unsigned int xx = xpos >> 16;
|
|
|
|
register unsigned int xalpha = (xpos & 0xFFFF) >> 9;
|
|
|
|
dst1[i] = (src1[xx] * (xalpha ^ 127) + src1[xx + 1] * xalpha);
|
|
|
|
dst2[i] = (src2[xx] * (xalpha ^ 127) + src2[xx + 1] * xalpha);
|
|
|
|
xpos += xInc;
|
2010-01-24 05:02:40 +02:00
|
|
|
}
|
2011-06-04 07:31:35 +03:00
|
|
|
for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) {
|
|
|
|
dst1[i] = src1[srcW-1]*128;
|
|
|
|
dst2[i] = src2[srcW-1]*128;
|
2010-01-24 05:02:40 +02:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2007-04-27 02:07:11 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static av_always_inline void hcscale(SwsContext *c, int16_t *dst1,
|
|
|
|
int16_t *dst2, int dstWidth,
|
2011-11-24 21:40:05 +03:00
|
|
|
const uint8_t *src_in[4],
|
2012-04-01 11:34:10 +03:00
|
|
|
int srcW, int xInc,
|
|
|
|
const int16_t *hChrFilter,
|
|
|
|
const int32_t *hChrFilterPos,
|
|
|
|
int hChrFilterSize,
|
2011-06-08 19:31:11 +03:00
|
|
|
uint8_t *formatConvBuffer, uint32_t *pal)
|
2011-06-03 08:34:12 +03:00
|
|
|
{
|
2011-11-24 21:40:05 +03:00
|
|
|
const uint8_t *src1 = src_in[1], *src2 = src_in[2];
|
2011-06-03 08:34:12 +03:00
|
|
|
if (c->chrToYV12) {
|
2012-04-01 11:34:10 +03:00
|
|
|
uint8_t *buf2 = formatConvBuffer +
|
2012-04-13 22:21:15 +03:00
|
|
|
FFALIGN(srcW*2+78, 16);
|
2011-11-25 03:38:21 +03:00
|
|
|
c->chrToYV12(formatConvBuffer, buf2, src_in[0], src1, src2, srcW, pal);
|
2011-06-03 08:34:12 +03:00
|
|
|
src1= formatConvBuffer;
|
|
|
|
src2= buf2;
|
2011-11-24 21:40:05 +03:00
|
|
|
} else if (c->readChrPlanar) {
|
2012-04-01 11:34:10 +03:00
|
|
|
uint8_t *buf2 = formatConvBuffer +
|
2012-04-13 22:21:15 +03:00
|
|
|
FFALIGN(srcW*2+78, 16);
|
2011-11-24 21:40:05 +03:00
|
|
|
c->readChrPlanar(formatConvBuffer, buf2, src_in, srcW);
|
2012-04-01 11:34:10 +03:00
|
|
|
src1 = formatConvBuffer;
|
|
|
|
src2 = buf2;
|
2010-01-24 05:02:40 +02:00
|
|
|
}
|
2004-07-06 16:52:56 +03:00
|
|
|
|
2011-09-14 01:32:18 +03:00
|
|
|
if (!c->hcscale_fast) {
|
2011-08-03 21:25:01 +03:00
|
|
|
c->hcScale(c, dst1, dstWidth, src1, hChrFilter, hChrFilterPos, hChrFilterSize);
|
|
|
|
c->hcScale(c, dst2, dstWidth, src2, hChrFilter, hChrFilterPos, hChrFilterSize);
|
2011-06-03 08:34:12 +03:00
|
|
|
} else { // fast bilinear upscale / crap downscale
|
|
|
|
c->hcscale_fast(c, dst1, dst2, dstWidth, src1, src2, srcW, xInc);
|
2010-01-24 05:02:40 +02:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
if (c->chrConvertRange)
|
|
|
|
c->chrConvertRange(dst1, dst2, dstWidth);
|
2002-01-20 07:30:23 +02:00
|
|
|
}
|
|
|
|
|
2011-06-03 08:34:12 +03:00
|
|
|
#define DEBUG_SWSCALE_BUFFERS 0
|
2012-04-01 11:34:10 +03:00
|
|
|
#define DEBUG_BUFFERS(...) \
|
|
|
|
if (DEBUG_SWSCALE_BUFFERS) \
|
|
|
|
av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
static int swScale(SwsContext *c, const uint8_t *src[],
|
2011-06-03 08:34:13 +03:00
|
|
|
int srcStride[], int srcSliceY,
|
2012-04-01 11:34:10 +03:00
|
|
|
int srcSliceH, uint8_t *dst[], int dstStride[])
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2012-04-01 11:34:10 +03:00
|
|
|
/* load a few things into local vars to make the code more readable?
|
|
|
|
* and faster */
|
|
|
|
const int srcW = c->srcW;
|
|
|
|
const int dstW = c->dstW;
|
|
|
|
const int dstH = c->dstH;
|
|
|
|
const int chrDstW = c->chrDstW;
|
|
|
|
const int chrSrcW = c->chrSrcW;
|
|
|
|
const int lumXInc = c->lumXInc;
|
|
|
|
const int chrXInc = c->chrXInc;
|
|
|
|
const enum PixelFormat dstFormat = c->dstFormat;
|
|
|
|
const int flags = c->flags;
|
|
|
|
int32_t *vLumFilterPos = c->vLumFilterPos;
|
|
|
|
int32_t *vChrFilterPos = c->vChrFilterPos;
|
|
|
|
int32_t *hLumFilterPos = c->hLumFilterPos;
|
|
|
|
int32_t *hChrFilterPos = c->hChrFilterPos;
|
|
|
|
int16_t *vLumFilter = c->vLumFilter;
|
|
|
|
int16_t *vChrFilter = c->vChrFilter;
|
|
|
|
int16_t *hLumFilter = c->hLumFilter;
|
|
|
|
int16_t *hChrFilter = c->hChrFilter;
|
|
|
|
int32_t *lumMmxFilter = c->lumMmxFilter;
|
|
|
|
int32_t *chrMmxFilter = c->chrMmxFilter;
|
|
|
|
const int vLumFilterSize = c->vLumFilterSize;
|
|
|
|
const int vChrFilterSize = c->vChrFilterSize;
|
|
|
|
const int hLumFilterSize = c->hLumFilterSize;
|
|
|
|
const int hChrFilterSize = c->hChrFilterSize;
|
|
|
|
int16_t **lumPixBuf = c->lumPixBuf;
|
|
|
|
int16_t **chrUPixBuf = c->chrUPixBuf;
|
|
|
|
int16_t **chrVPixBuf = c->chrVPixBuf;
|
|
|
|
int16_t **alpPixBuf = c->alpPixBuf;
|
|
|
|
const int vLumBufSize = c->vLumBufSize;
|
|
|
|
const int vChrBufSize = c->vChrBufSize;
|
|
|
|
uint8_t *formatConvBuffer = c->formatConvBuffer;
|
|
|
|
uint32_t *pal = c->pal_yuv;
|
|
|
|
yuv2planar1_fn yuv2plane1 = c->yuv2plane1;
|
|
|
|
yuv2planarX_fn yuv2planeX = c->yuv2planeX;
|
|
|
|
yuv2interleavedX_fn yuv2nv12cX = c->yuv2nv12cX;
|
|
|
|
yuv2packed1_fn yuv2packed1 = c->yuv2packed1;
|
|
|
|
yuv2packed2_fn yuv2packed2 = c->yuv2packed2;
|
|
|
|
yuv2packedX_fn yuv2packedX = c->yuv2packedX;
|
|
|
|
const int chrSrcSliceY = srcSliceY >> c->chrSrcVSubSample;
|
|
|
|
const int chrSrcSliceH = -((-srcSliceH) >> c->chrSrcVSubSample);
|
|
|
|
int should_dither = is9_OR_10BPS(c->srcFormat) ||
|
|
|
|
is16BPS(c->srcFormat);
|
2011-06-03 08:34:12 +03:00
|
|
|
int lastDstY;
|
|
|
|
|
|
|
|
/* vars which will change and which we need to store back in the context */
|
2012-04-01 11:34:10 +03:00
|
|
|
int dstY = c->dstY;
|
|
|
|
int lumBufIndex = c->lumBufIndex;
|
|
|
|
int chrBufIndex = c->chrBufIndex;
|
|
|
|
int lastInLumBuf = c->lastInLumBuf;
|
|
|
|
int lastInChrBuf = c->lastInChrBuf;
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
if (isPacked(c->srcFormat)) {
|
2012-04-01 11:34:10 +03:00
|
|
|
src[0] =
|
|
|
|
src[1] =
|
|
|
|
src[2] =
|
|
|
|
src[3] = src[0];
|
|
|
|
srcStride[0] =
|
|
|
|
srcStride[1] =
|
|
|
|
srcStride[2] =
|
|
|
|
srcStride[3] = srcStride[0];
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
srcStride[1] <<= c->vChrDrop;
|
|
|
|
srcStride[2] <<= c->vChrDrop;
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
src[0], srcStride[0], src[1], srcStride[1],
|
|
|
|
src[2], srcStride[2], src[3], srcStride[3],
|
|
|
|
dst[0], dstStride[0], dst[1], dstStride[1],
|
|
|
|
dst[2], dstStride[2], dst[3], dstStride[3]);
|
2011-06-03 08:34:12 +03:00
|
|
|
DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
srcSliceY, srcSliceH, dstY, dstH);
|
2011-06-03 08:34:12 +03:00
|
|
|
DEBUG_BUFFERS("vLumFilterSize: %d vLumBufSize: %d vChrFilterSize: %d vChrBufSize: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
vLumFilterSize, vLumBufSize, vChrFilterSize, vChrBufSize);
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-04-13 22:21:15 +03:00
|
|
|
if (dstStride[0]%16 !=0 || dstStride[1]%16 !=0 ||
|
|
|
|
dstStride[2]%16 !=0 || dstStride[3]%16 != 0) {
|
2012-04-01 11:34:10 +03:00
|
|
|
static int warnedAlready = 0; // FIXME maybe move this into the context
|
2011-06-03 08:34:12 +03:00
|
|
|
if (flags & SWS_PRINT_INFO && !warnedAlready) {
|
2012-04-01 11:34:10 +03:00
|
|
|
av_log(c, AV_LOG_WARNING,
|
|
|
|
"Warning: dstStride is not aligned!\n"
|
2011-06-03 08:34:12 +03:00
|
|
|
" ->cannot do aligned memory accesses anymore\n");
|
2012-04-01 11:34:10 +03:00
|
|
|
warnedAlready = 1;
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
|
|
|
}
|
2010-01-16 13:08:16 +02:00
|
|
|
|
2011-10-31 03:36:02 +03:00
|
|
|
if ((int)dst[0]%16 || (int)dst[1]%16 || (int)dst[2]%16 || (int)src[0]%16 || (int)src[1]%16 || (int)src[2]%16
|
|
|
|
|| dstStride[0]%16 || dstStride[1]%16 || dstStride[2]%16 || dstStride[3]%16
|
|
|
|
|| srcStride[0]%16 || srcStride[1]%16 || srcStride[2]%16 || srcStride[3]%16
|
|
|
|
) {
|
|
|
|
static int warnedAlready=0;
|
|
|
|
int cpu_flags = av_get_cpu_flags();
|
|
|
|
if (HAVE_MMX2 && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){
|
|
|
|
av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speedloss\n");
|
|
|
|
warnedAlready=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-03 08:34:12 +03:00
|
|
|
/* Note the user might start scaling the picture in the middle so this
|
2012-04-01 11:34:10 +03:00
|
|
|
* will not get executed. This is not really intended but works
|
|
|
|
* currently, so people might do it. */
|
|
|
|
if (srcSliceY == 0) {
|
|
|
|
lumBufIndex = -1;
|
|
|
|
chrBufIndex = -1;
|
|
|
|
dstY = 0;
|
|
|
|
lastInLumBuf = -1;
|
|
|
|
lastInChrBuf = -1;
|
2009-04-21 03:01:59 +03:00
|
|
|
}
|
|
|
|
|
2011-07-05 22:49:11 +03:00
|
|
|
if (!should_dither) {
|
|
|
|
c->chrDither8 = c->lumDither8 = ff_sws_pb_64;
|
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
lastDstY = dstY;
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
for (; dstY < dstH; dstY++) {
|
|
|
|
const int chrDstY = dstY >> c->chrDstVSubSample;
|
|
|
|
uint8_t *dest[4] = {
|
2011-06-16 19:04:26 +03:00
|
|
|
dst[0] + dstStride[0] * dstY,
|
|
|
|
dst[1] + dstStride[1] * chrDstY,
|
|
|
|
dst[2] + dstStride[2] * chrDstY,
|
|
|
|
(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3] + dstStride[3] * dstY : NULL,
|
|
|
|
};
|
2011-10-23 20:19:57 +03:00
|
|
|
int use_mmx_vfilter= c->use_mmx_vfilter;
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
// First line needed as input
|
|
|
|
const int firstLumSrcY = FFMAX(1 - vLumFilterSize, vLumFilterPos[dstY]);
|
|
|
|
const int firstLumSrcY2 = FFMAX(1 - vLumFilterSize, vLumFilterPos[FFMIN(dstY | ((1 << c->chrDstVSubSample) - 1), dstH - 1)]);
|
|
|
|
// First line needed as input
|
|
|
|
const int firstChrSrcY = FFMAX(1 - vChrFilterSize, vChrFilterPos[chrDstY]);
|
swscale: fix overflows in vertical scaling at top/bottom edges.
This fixes integer multiplication overflows in RGB48 output
(vertical) scaling as detected by IOC. What happens is that for
certain types of filters (lanczos, spline, bicubic), the
intermediate sum of coefficients in the middle of a filter can
be larger than the fixed-point equivalent of 1.0, even if the
final sum is 1.0. This is fine and we support that.
However, at frame edges, initFilter() will merge the coefficients
for the off-screen pixels into the top or bottom pixel, such as
to emulate edge extension. This means that suddenly, a single
coefficient can be larger than the fixed-point equivalent of
1.0, which the vertical scaling routines do not support.
Therefore, remove the merging of coefficients for edges for
the vertical scaling filter, and instead add edge detection
to the scaler itself so that it copies the pointers (not data)
for the edges (i.e. it uses line[0] for line[-1] as well), so
that a single coefficient is never larger than the fixed-point
equivalent of 1.0.
2011-12-18 19:27:43 +03:00
|
|
|
|
|
|
|
// Last line needed as input
|
|
|
|
int lastLumSrcY = FFMIN(c->srcH, firstLumSrcY + vLumFilterSize) - 1;
|
|
|
|
int lastLumSrcY2 = FFMIN(c->srcH, firstLumSrcY2 + vLumFilterSize) - 1;
|
|
|
|
int lastChrSrcY = FFMIN(c->chrSrcH, firstChrSrcY + vChrFilterSize) - 1;
|
2011-06-03 08:34:12 +03:00
|
|
|
int enough_lines;
|
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
// handle holes (FAST_BILINEAR & weird filters)
|
|
|
|
if (firstLumSrcY > lastInLumBuf)
|
|
|
|
lastInLumBuf = firstLumSrcY - 1;
|
|
|
|
if (firstChrSrcY > lastInChrBuf)
|
|
|
|
lastInChrBuf = firstChrSrcY - 1;
|
2011-06-03 08:34:12 +03:00
|
|
|
assert(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1);
|
|
|
|
assert(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1);
|
|
|
|
|
|
|
|
DEBUG_BUFFERS("dstY: %d\n", dstY);
|
|
|
|
DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
firstLumSrcY, lastLumSrcY, lastInLumBuf);
|
2011-06-03 08:34:12 +03:00
|
|
|
DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
firstChrSrcY, lastChrSrcY, lastInChrBuf);
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
// Do we have enough lines in this slice to output the dstY line
|
2012-04-01 11:34:10 +03:00
|
|
|
enough_lines = lastLumSrcY2 < srcSliceY + srcSliceH &&
|
|
|
|
lastChrSrcY < -((-srcSliceY - srcSliceH) >> c->chrSrcVSubSample);
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
if (!enough_lines) {
|
|
|
|
lastLumSrcY = srcSliceY + srcSliceH - 1;
|
|
|
|
lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;
|
|
|
|
DEBUG_BUFFERS("buffering slice: lastLumSrcY %d lastChrSrcY %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
lastLumSrcY, lastChrSrcY);
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2010-08-18 22:37:37 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
// Do horizontal scaling
|
|
|
|
while (lastInLumBuf < lastLumSrcY) {
|
2011-11-24 21:40:05 +03:00
|
|
|
const uint8_t *src1[4] = {
|
|
|
|
src[0] + (lastInLumBuf + 1 - srcSliceY) * srcStride[0],
|
|
|
|
src[1] + (lastInLumBuf + 1 - srcSliceY) * srcStride[1],
|
|
|
|
src[2] + (lastInLumBuf + 1 - srcSliceY) * srcStride[2],
|
|
|
|
src[3] + (lastInLumBuf + 1 - srcSliceY) * srcStride[3],
|
|
|
|
};
|
2011-06-03 08:34:12 +03:00
|
|
|
lumBufIndex++;
|
2012-04-01 11:34:10 +03:00
|
|
|
assert(lumBufIndex < 2 * vLumBufSize);
|
2011-06-03 08:34:12 +03:00
|
|
|
assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);
|
|
|
|
assert(lastInLumBuf + 1 - srcSliceY >= 0);
|
2012-04-01 11:34:10 +03:00
|
|
|
hyscale(c, lumPixBuf[lumBufIndex], dstW, src1, srcW, lumXInc,
|
2011-06-03 08:34:13 +03:00
|
|
|
hLumFilter, hLumFilterPos, hLumFilterSize,
|
2012-04-01 11:34:10 +03:00
|
|
|
formatConvBuffer, pal, 0);
|
2011-06-03 08:34:12 +03:00
|
|
|
if (CONFIG_SWSCALE_ALPHA && alpPixBuf)
|
2012-04-01 11:34:10 +03:00
|
|
|
hyscale(c, alpPixBuf[lumBufIndex], dstW, src1, srcW,
|
2011-06-03 08:34:13 +03:00
|
|
|
lumXInc, hLumFilter, hLumFilterPos, hLumFilterSize,
|
2012-04-01 11:34:10 +03:00
|
|
|
formatConvBuffer, pal, 1);
|
2011-06-03 08:34:12 +03:00
|
|
|
lastInLumBuf++;
|
|
|
|
DEBUG_BUFFERS("\t\tlumBufIndex %d: lastInLumBuf: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
lumBufIndex, lastInLumBuf);
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
while (lastInChrBuf < lastChrSrcY) {
|
2011-11-24 21:40:05 +03:00
|
|
|
const uint8_t *src1[4] = {
|
|
|
|
src[0] + (lastInChrBuf + 1 - chrSrcSliceY) * srcStride[0],
|
|
|
|
src[1] + (lastInChrBuf + 1 - chrSrcSliceY) * srcStride[1],
|
|
|
|
src[2] + (lastInChrBuf + 1 - chrSrcSliceY) * srcStride[2],
|
|
|
|
src[3] + (lastInChrBuf + 1 - chrSrcSliceY) * srcStride[3],
|
|
|
|
};
|
2011-06-03 08:34:12 +03:00
|
|
|
chrBufIndex++;
|
2012-04-01 11:34:10 +03:00
|
|
|
assert(chrBufIndex < 2 * vChrBufSize);
|
2011-06-03 08:34:12 +03:00
|
|
|
assert(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH));
|
|
|
|
assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);
|
2012-04-01 11:34:10 +03:00
|
|
|
// FIXME replace parameters through context struct (some at least)
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
if (c->needs_hcscale)
|
2011-06-03 08:34:13 +03:00
|
|
|
hcscale(c, chrUPixBuf[chrBufIndex], chrVPixBuf[chrBufIndex],
|
2012-04-01 11:34:10 +03:00
|
|
|
chrDstW, src1, chrSrcW, chrXInc,
|
|
|
|
hChrFilter, hChrFilterPos, hChrFilterSize,
|
|
|
|
formatConvBuffer, pal);
|
2011-06-03 08:34:12 +03:00
|
|
|
lastInChrBuf++;
|
|
|
|
DEBUG_BUFFERS("\t\tchrBufIndex %d: lastInChrBuf: %d\n",
|
2012-04-01 11:34:10 +03:00
|
|
|
chrBufIndex, lastInChrBuf);
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
// wrap buf index around to stay inside the ring buffer
|
|
|
|
if (lumBufIndex >= vLumBufSize)
|
|
|
|
lumBufIndex -= vLumBufSize;
|
|
|
|
if (chrBufIndex >= vChrBufSize)
|
|
|
|
chrBufIndex -= vChrBufSize;
|
2011-06-03 08:34:12 +03:00
|
|
|
if (!enough_lines)
|
2012-04-01 11:34:10 +03:00
|
|
|
break; // we can't output a dstY line so let's try with the next slice
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-07-22 23:55:58 +03:00
|
|
|
#if HAVE_MMX && HAVE_INLINE_ASM
|
2012-04-01 11:34:10 +03:00
|
|
|
updateMMXDitherTables(c, dstY, lumBufIndex, chrBufIndex,
|
|
|
|
lastInLumBuf, lastInChrBuf);
|
2011-06-03 08:34:12 +03:00
|
|
|
#endif
|
2011-07-05 22:49:11 +03:00
|
|
|
if (should_dither) {
|
|
|
|
c->chrDither8 = dither_8x8_128[chrDstY & 7];
|
2012-04-01 11:34:10 +03:00
|
|
|
c->lumDither8 = dither_8x8_128[dstY & 7];
|
2011-07-05 22:49:11 +03:00
|
|
|
}
|
2012-04-01 11:34:10 +03:00
|
|
|
if (dstY >= dstH - 2) {
|
|
|
|
/* hmm looks like we can't use MMX here without overwriting
|
|
|
|
* this array's tail */
|
|
|
|
ff_sws_init_output_funcs(c, &yuv2plane1, &yuv2planeX, &yuv2nv12cX,
|
2012-02-01 18:38:56 +03:00
|
|
|
&yuv2packed1, &yuv2packed2, &yuv2packedX);
|
2011-10-23 20:19:57 +03:00
|
|
|
use_mmx_vfilter= 0;
|
2011-06-06 05:54:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2012-04-13 22:21:15 +03:00
|
|
|
const int16_t **lumSrcPtr = (const int16_t **)(void*) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
|
|
|
|
const int16_t **chrUSrcPtr = (const int16_t **)(void*) chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
|
|
|
|
const int16_t **chrVSrcPtr = (const int16_t **)(void*) chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
|
2012-04-01 11:34:10 +03:00
|
|
|
const int16_t **alpSrcPtr = (CONFIG_SWSCALE_ALPHA && alpPixBuf) ?
|
2012-04-13 22:21:15 +03:00
|
|
|
(const int16_t **)(void*) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
|
|
|
|
int16_t *vLumFilter = c->vLumFilter;
|
|
|
|
int16_t *vChrFilter = c->vChrFilter;
|
swscale: fix overflows in vertical scaling at top/bottom edges.
This fixes integer multiplication overflows in RGB48 output
(vertical) scaling as detected by IOC. What happens is that for
certain types of filters (lanczos, spline, bicubic), the
intermediate sum of coefficients in the middle of a filter can
be larger than the fixed-point equivalent of 1.0, even if the
final sum is 1.0. This is fine and we support that.
However, at frame edges, initFilter() will merge the coefficients
for the off-screen pixels into the top or bottom pixel, such as
to emulate edge extension. This means that suddenly, a single
coefficient can be larger than the fixed-point equivalent of
1.0, which the vertical scaling routines do not support.
Therefore, remove the merging of coefficients for edges for
the vertical scaling filter, and instead add edge detection
to the scaler itself so that it copies the pointers (not data)
for the edges (i.e. it uses line[0] for line[-1] as well), so
that a single coefficient is never larger than the fixed-point
equivalent of 1.0.
2011-12-18 19:27:43 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
if (isPlanarYUV(dstFormat) ||
|
|
|
|
(isGray(dstFormat) && !isALPHA(dstFormat))) { // YV12 like
|
|
|
|
const int chrSkipMask = (1 << c->chrDstVSubSample) - 1;
|
2011-09-30 15:50:49 +03:00
|
|
|
|
2011-10-23 20:18:59 +03:00
|
|
|
vLumFilter += dstY * vLumFilterSize;
|
|
|
|
vChrFilter += chrDstY * vChrFilterSize;
|
|
|
|
|
2012-02-08 04:59:09 +03:00
|
|
|
// av_assert0(use_mmx_vfilter != (
|
|
|
|
// yuv2planeX == yuv2planeX_10BE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_10LE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_9BE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_9LE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_16BE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_16LE_c
|
|
|
|
// || yuv2planeX == yuv2planeX_8_c) || !ARCH_X86);
|
2011-10-23 21:18:21 +03:00
|
|
|
|
2011-10-23 20:19:57 +03:00
|
|
|
if(use_mmx_vfilter){
|
|
|
|
vLumFilter= c->lumMmxFilter;
|
|
|
|
vChrFilter= c->chrMmxFilter;
|
|
|
|
}
|
|
|
|
|
2011-10-05 17:37:24 +03:00
|
|
|
if (vLumFilterSize == 1) {
|
|
|
|
yuv2plane1(lumSrcPtr[0], dest[0], dstW, c->lumDither8, 0);
|
|
|
|
} else {
|
2011-10-23 20:18:59 +03:00
|
|
|
yuv2planeX(vLumFilter, vLumFilterSize,
|
2012-04-13 22:21:15 +03:00
|
|
|
lumSrcPtr, dest[0],
|
2012-04-01 11:34:10 +03:00
|
|
|
dstW, c->lumDither8, 0);
|
2011-10-05 17:37:24 +03:00
|
|
|
}
|
2011-09-30 15:50:49 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
if (!((dstY & chrSkipMask) || isGray(dstFormat))) {
|
2011-10-05 17:37:24 +03:00
|
|
|
if (yuv2nv12cX) {
|
2012-04-13 22:21:15 +03:00
|
|
|
yuv2nv12cX(c, vChrFilter,
|
2012-04-01 11:34:10 +03:00
|
|
|
vChrFilterSize, chrUSrcPtr, chrVSrcPtr,
|
|
|
|
dest[1], chrDstW);
|
2011-10-05 17:37:24 +03:00
|
|
|
} else if (vChrFilterSize == 1) {
|
|
|
|
yuv2plane1(chrUSrcPtr[0], dest[1], chrDstW, c->chrDither8, 0);
|
|
|
|
yuv2plane1(chrVSrcPtr[0], dest[2], chrDstW, c->chrDither8, 3);
|
|
|
|
} else {
|
2012-04-13 22:21:15 +03:00
|
|
|
yuv2planeX(vChrFilter,
|
2012-04-01 11:34:10 +03:00
|
|
|
vChrFilterSize, chrUSrcPtr, dest[1],
|
|
|
|
chrDstW, c->chrDither8, 0);
|
2012-04-13 22:21:15 +03:00
|
|
|
yuv2planeX(vChrFilter,
|
2012-04-01 11:34:10 +03:00
|
|
|
vChrFilterSize, chrVSrcPtr, dest[2],
|
2012-04-13 22:21:15 +03:00
|
|
|
chrDstW, c->chrDither8, use_mmx_vfilter ? (c->uv_offx2 >> 1) : 3);
|
2011-09-30 15:50:49 +03:00
|
|
|
}
|
2011-10-05 17:37:24 +03:00
|
|
|
}
|
2011-09-30 15:50:49 +03:00
|
|
|
|
2012-04-01 11:34:10 +03:00
|
|
|
if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {
|
2011-10-23 20:19:57 +03:00
|
|
|
if(use_mmx_vfilter){
|
|
|
|
vLumFilter= c->alpMmxFilter;
|
|
|
|
}
|
2011-10-05 17:37:24 +03:00
|
|
|
if (vLumFilterSize == 1) {
|
2012-04-01 11:34:10 +03:00
|
|
|
yuv2plane1(alpSrcPtr[0], dest[3], dstW,
|
|
|
|
c->lumDither8, 0);
|
2011-10-05 17:37:24 +03:00
|
|
|
} else {
|
2012-04-13 22:21:15 +03:00
|
|
|
yuv2planeX(vLumFilter,
|
2012-04-01 11:34:10 +03:00
|
|
|
vLumFilterSize, alpSrcPtr, dest[3],
|
|
|
|
dstW, c->lumDither8, 0);
|
2011-10-04 14:22:03 +03:00
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
|
|
|
} else {
|
2012-04-01 11:34:10 +03:00
|
|
|
assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize * 2);
|
|
|
|
assert(chrUSrcPtr + vChrFilterSize - 1 < chrUPixBuf + vChrBufSize * 2);
|
|
|
|
if (c->yuv2packed1 && vLumFilterSize == 1 &&
|
|
|
|
vChrFilterSize <= 2) { // unscaled RGB
|
2012-02-13 02:48:24 +03:00
|
|
|
int chrAlpha = vChrFilterSize == 1 ? 0 : vChrFilter[2 * dstY + 1];
|
2011-06-16 19:04:26 +03:00
|
|
|
yuv2packed1(c, *lumSrcPtr, chrUSrcPtr, chrVSrcPtr,
|
|
|
|
alpPixBuf ? *alpSrcPtr : NULL,
|
|
|
|
dest[0], dstW, chrAlpha, dstY);
|
2012-04-01 11:34:10 +03:00
|
|
|
} else if (c->yuv2packed2 && vLumFilterSize == 2 &&
|
|
|
|
vChrFilterSize == 2) { // bilinear upscale RGB
|
2011-06-16 19:04:26 +03:00
|
|
|
int lumAlpha = vLumFilter[2 * dstY + 1];
|
|
|
|
int chrAlpha = vChrFilter[2 * dstY + 1];
|
|
|
|
lumMmxFilter[2] =
|
2012-04-01 11:34:10 +03:00
|
|
|
lumMmxFilter[3] = vLumFilter[2 * dstY] * 0x10001;
|
2011-06-16 19:04:26 +03:00
|
|
|
chrMmxFilter[2] =
|
|
|
|
chrMmxFilter[3] = vChrFilter[2 * chrDstY] * 0x10001;
|
|
|
|
yuv2packed2(c, lumSrcPtr, chrUSrcPtr, chrVSrcPtr,
|
|
|
|
alpPixBuf ? alpSrcPtr : NULL,
|
|
|
|
dest[0], dstW, lumAlpha, chrAlpha, dstY);
|
2012-04-01 11:34:10 +03:00
|
|
|
} else { // general RGB
|
2011-06-16 19:04:26 +03:00
|
|
|
yuv2packedX(c, vLumFilter + dstY * vLumFilterSize,
|
|
|
|
lumSrcPtr, vLumFilterSize,
|
|
|
|
vChrFilter + dstY * vChrFilterSize,
|
|
|
|
chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
|
|
|
|
alpSrcPtr, dest[0], dstW, dstY);
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-08-18 22:37:37 +03:00
|
|
|
}
|
|
|
|
|
2012-01-30 16:58:50 +03:00
|
|
|
if (isPlanar(dstFormat) && isALPHA(dstFormat) && !alpPixBuf)
|
2012-04-01 11:34:10 +03:00
|
|
|
fillPlane(dst[3], dstStride[3], dstW, dstY - lastDstY, lastDstY, 255);
|
2011-06-03 08:34:12 +03:00
|
|
|
|
2012-07-08 19:42:12 +03:00
|
|
|
#if HAVE_MMXEXT && HAVE_INLINE_ASM
|
|
|
|
if (av_get_cpu_flags() & AV_CPU_FLAG_MMXEXT)
|
2012-04-01 11:34:10 +03:00
|
|
|
__asm__ volatile ("sfence" ::: "memory");
|
2011-06-03 08:34:12 +03:00
|
|
|
#endif
|
|
|
|
emms_c();
|
|
|
|
|
|
|
|
/* store changed local vars back in the context */
|
2012-04-01 11:34:10 +03:00
|
|
|
c->dstY = dstY;
|
|
|
|
c->lumBufIndex = lumBufIndex;
|
|
|
|
c->chrBufIndex = chrBufIndex;
|
|
|
|
c->lastInLumBuf = lastInLumBuf;
|
|
|
|
c->lastInChrBuf = lastInChrBuf;
|
2011-06-03 08:34:12 +03:00
|
|
|
|
|
|
|
return dstY - lastDstY;
|
2010-08-18 22:37:37 +03:00
|
|
|
}
|
|
|
|
|
2011-06-08 19:31:11 +03:00
|
|
|
static av_cold void sws_init_swScale_c(SwsContext *c)
|
2009-08-17 00:11:28 +03:00
|
|
|
{
|
2011-06-03 08:34:12 +03:00
|
|
|
enum PixelFormat srcFormat = c->srcFormat;
|
2008-09-04 23:46:36 +03:00
|
|
|
|
2012-02-01 18:38:56 +03:00
|
|
|
ff_sws_init_output_funcs(c, &c->yuv2plane1, &c->yuv2planeX,
|
|
|
|
&c->yuv2nv12cX, &c->yuv2packed1,
|
|
|
|
&c->yuv2packed2, &c->yuv2packedX);
|
2007-04-29 16:39:27 +03:00
|
|
|
|
2012-02-01 18:38:55 +03:00
|
|
|
ff_sws_init_input_funcs(c);
|
2007-04-15 03:53:32 +03:00
|
|
|
|
2009-04-21 03:01:59 +03:00
|
|
|
|
2011-08-03 01:42:35 +03:00
|
|
|
if (c->srcBpc == 8) {
|
2012-07-03 05:10:11 +03:00
|
|
|
if (c->dstBpc <= 14) {
|
2011-08-03 21:25:01 +03:00
|
|
|
c->hyScale = c->hcScale = hScale8To15_c;
|
2011-08-03 01:42:35 +03:00
|
|
|
if (c->flags & SWS_FAST_BILINEAR) {
|
|
|
|
c->hyscale_fast = hyscale_fast_c;
|
|
|
|
c->hcscale_fast = hcscale_fast_c;
|
|
|
|
}
|
2011-06-03 08:34:12 +03:00
|
|
|
} else {
|
2011-08-03 21:25:01 +03:00
|
|
|
c->hyScale = c->hcScale = hScale8To19_c;
|
2011-06-03 08:34:12 +03:00
|
|
|
}
|
2011-06-29 19:39:43 +03:00
|
|
|
} else {
|
2012-07-03 05:10:11 +03:00
|
|
|
c->hyScale = c->hcScale = c->dstBpc > 14 ? hScale16To19_c
|
2012-04-01 11:34:10 +03:00
|
|
|
: hScale16To15_c;
|
2011-08-03 01:42:35 +03:00
|
|
|
}
|
2011-06-29 19:39:43 +03:00
|
|
|
|
2011-08-03 01:42:35 +03:00
|
|
|
if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {
|
2012-07-03 05:10:11 +03:00
|
|
|
if (c->dstBpc <= 14) {
|
2011-08-03 01:42:35 +03:00
|
|
|
if (c->srcRange) {
|
|
|
|
c->lumConvertRange = lumRangeFromJpeg_c;
|
|
|
|
c->chrConvertRange = chrRangeFromJpeg_c;
|
|
|
|
} else {
|
|
|
|
c->lumConvertRange = lumRangeToJpeg_c;
|
|
|
|
c->chrConvertRange = chrRangeToJpeg_c;
|
|
|
|
}
|
|
|
|
} else {
|
2011-06-29 19:39:43 +03:00
|
|
|
if (c->srcRange) {
|
|
|
|
c->lumConvertRange = lumRangeFromJpeg16_c;
|
|
|
|
c->chrConvertRange = chrRangeFromJpeg16_c;
|
|
|
|
} else {
|
|
|
|
c->lumConvertRange = lumRangeToJpeg16_c;
|
|
|
|
c->chrConvertRange = chrRangeToJpeg16_c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-03-27 18:04:53 +02:00
|
|
|
|
2011-06-03 08:34:12 +03:00
|
|
|
if (!(isGray(srcFormat) || isGray(c->dstFormat) ||
|
|
|
|
srcFormat == PIX_FMT_MONOBLACK || srcFormat == PIX_FMT_MONOWHITE))
|
|
|
|
c->needs_hcscale = 1;
|
2003-02-24 00:05:55 +02:00
|
|
|
}
|
2010-06-01 22:35:16 +03:00
|
|
|
|
2010-01-24 04:08:22 +02:00
|
|
|
SwsFunc ff_getSwsFunc(SwsContext *c)
|
2010-06-01 22:35:16 +03:00
|
|
|
{
|
2011-04-13 21:57:30 +03:00
|
|
|
sws_init_swScale_c(c);
|
2010-06-01 22:35:16 +03:00
|
|
|
|
2011-06-03 08:00:00 +03:00
|
|
|
if (HAVE_MMX)
|
|
|
|
ff_sws_init_swScale_mmx(c);
|
2011-06-03 06:04:04 +03:00
|
|
|
if (HAVE_ALTIVEC)
|
|
|
|
ff_sws_init_swScale_altivec(c);
|
2010-06-01 22:35:16 +03:00
|
|
|
|
2011-06-03 08:34:13 +03:00
|
|
|
return swScale;
|
2010-06-01 22:35:16 +03:00
|
|
|
}
|