2002-01-21 18:32:31 +00:00
|
|
|
/*
|
2011-11-18 20:44:26 +00:00
|
|
|
* Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
|
2006-10-07 15:33:14 +00:00
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
2010-03-27 11:31:02 +00: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 15:33:14 +00: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 11:31:02 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
2006-10-07 15:33:14 +00:00
|
|
|
*
|
2010-03-27 11:31:02 +00: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 10:18:58 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2006-10-07 15:33:14 +00:00
|
|
|
*/
|
2001-10-18 22:27:13 +00:00
|
|
|
|
2001-10-17 02:30:39 +00:00
|
|
|
#include <inttypes.h>
|
2001-12-02 20:03:26 +00:00
|
|
|
#include <math.h>
|
2001-12-06 00:10:42 +00:00
|
|
|
#include <stdio.h>
|
2012-04-01 08:34:10 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2011-05-24 20:59:11 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2009-08-29 23:02:01 +00:00
|
|
|
#include "libavutil/avutil.h"
|
2008-05-09 12:00:25 +00:00
|
|
|
#include "libavutil/bswap.h"
|
2012-04-01 08:34:10 +00:00
|
|
|
#include "libavutil/cpu.h"
|
2014-10-08 00:05:54 +00:00
|
|
|
#include "libavutil/imgutils.h"
|
2012-04-01 08:34:10 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
|
|
|
#include "libavutil/mathematics.h"
|
2020-05-27 12:54:38 +00:00
|
|
|
#include "libavutil/mem_internal.h"
|
2009-11-26 21:08:45 +00:00
|
|
|
#include "libavutil/pixdesc.h"
|
2012-04-01 08:34:10 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include "rgb2rgb.h"
|
|
|
|
#include "swscale_internal.h"
|
|
|
|
#include "swscale.h"
|
2002-06-22 08:49:45 +00:00
|
|
|
|
2013-08-16 13:01:47 +00:00
|
|
|
DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_128)[9][8] = {
|
2012-04-01 08:34:10 +00: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, },
|
2013-08-16 13:01:47 +00:00
|
|
|
{ 36, 68, 60, 92, 34, 66, 58, 90, },
|
2011-07-05 19:49:11 +00:00
|
|
|
};
|
2002-01-21 15:22:28 +00:00
|
|
|
|
2013-08-15 11:29:01 +00:00
|
|
|
DECLARE_ALIGNED(8, static const uint8_t, sws_pb_64)[8] = {
|
2012-04-01 08:34:10 +00:00
|
|
|
64, 64, 64, 64, 64, 64, 64, 64
|
2011-07-05 19:49:11 +00:00
|
|
|
};
|
2012-02-08 01:59:09 +00:00
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
static av_always_inline void fillPlane(uint8_t *plane, int stride, int width,
|
|
|
|
int height, int y, uint8_t val)
|
2009-08-16 21:11:28 +00:00
|
|
|
{
|
2009-03-17 19:53:36 +00:00
|
|
|
int i;
|
2012-04-01 08:34:10 +00:00
|
|
|
uint8_t *ptr = plane + stride * y;
|
|
|
|
for (i = 0; i < height; i++) {
|
2009-03-17 19:53:36 +00:00
|
|
|
memset(ptr, val, width);
|
|
|
|
ptr += stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
static void hScale16To19_c(SwsContext *c, int16_t *_dst, int dstW,
|
|
|
|
const uint8_t *_src, const int16_t *filter,
|
2012-03-05 20:26:42 +00:00
|
|
|
const int32_t *filterPos, int filterSize)
|
2011-06-29 16:39:43 +00:00
|
|
|
{
|
2012-10-06 11:29:37 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
|
2011-06-29 16:39:43 +00:00
|
|
|
int i;
|
2012-04-01 08:34:10 +00:00
|
|
|
int32_t *dst = (int32_t *) _dst;
|
2011-06-29 16:39:43 +00:00
|
|
|
const uint16_t *src = (const uint16_t *) _src;
|
2015-09-03 11:44:14 +00:00
|
|
|
int bits = desc->comp[0].depth - 1;
|
2012-04-01 08:34:10 +00:00
|
|
|
int sh = bits - 4;
|
2011-06-29 16:39:43 +00:00
|
|
|
|
2018-08-20 13:28:00 +00:00
|
|
|
if ((isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
|
2018-08-20 13:31:01 +00:00
|
|
|
sh = 9;
|
2018-08-20 13:28:00 +00:00
|
|
|
} else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
|
|
|
|
sh = 16 - 1 - 4;
|
|
|
|
}
|
2011-07-03 00:08:45 +00:00
|
|
|
|
2011-06-29 16:39:43 +00:00
|
|
|
for (i = 0; i < dstW; i++) {
|
|
|
|
int j;
|
|
|
|
int srcPos = filterPos[i];
|
2012-04-01 08:34:10 +00:00
|
|
|
int val = 0;
|
2011-06-29 16:39:43 +00: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 00:35:13 +00:00
|
|
|
dst[i] = FFMIN(val >> sh, (1 << 19) - 1);
|
2011-06-29 16:39:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
static void hScale16To15_c(SwsContext *c, int16_t *dst, int dstW,
|
|
|
|
const uint8_t *_src, const int16_t *filter,
|
2012-03-05 20:26:42 +00:00
|
|
|
const int32_t *filterPos, int filterSize)
|
2011-08-02 22:42:35 +00:00
|
|
|
{
|
2012-10-06 11:29:37 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
|
2011-08-02 22:42:35 +00:00
|
|
|
int i;
|
|
|
|
const uint16_t *src = (const uint16_t *) _src;
|
2015-09-03 11:44:14 +00:00
|
|
|
int sh = desc->comp[0].depth - 1;
|
2011-08-02 22:42:35 +00:00
|
|
|
|
2018-08-20 13:28:00 +00:00
|
|
|
if (sh<15) {
|
2018-08-20 13:31:01 +00:00
|
|
|
sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
|
2018-08-20 13:28:00 +00:00
|
|
|
} else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
|
|
|
|
sh = 16 - 1;
|
|
|
|
}
|
2011-08-14 17:05:03 +00:00
|
|
|
|
2011-08-02 22:42:35 +00:00
|
|
|
for (i = 0; i < dstW; i++) {
|
|
|
|
int j;
|
|
|
|
int srcPos = filterPos[i];
|
2012-04-01 08:34:10 +00:00
|
|
|
int val = 0;
|
2011-08-02 22:42:35 +00: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 05:34:12 +00:00
|
|
|
// bilinear / bicubic scaling
|
2012-04-01 08:34:10 +00: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-16 21:11:28 +00:00
|
|
|
{
|
2008-10-08 17:46:22 +00:00
|
|
|
int i;
|
2012-04-01 08:34:10 +00:00
|
|
|
for (i = 0; i < dstW; i++) {
|
2011-06-03 05:34:12 +00:00
|
|
|
int j;
|
2012-04-01 08:34:10 +00: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-17 23:02:20 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
dst[i] = FFMIN(val >> 7, (1 << 15) - 1); // the cubic equation does overflow ...
|
2010-01-17 23:00:01 +00:00
|
|
|
}
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2008-10-08 17:46:22 +00:00
|
|
|
|
2012-04-01 08:34:10 +00: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-02 22:42:35 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dst = (int32_t *) _dst;
|
2012-04-01 08:34:10 +00:00
|
|
|
for (i = 0; i < dstW; i++) {
|
2011-08-02 22:42:35 +00:00
|
|
|
int j;
|
2012-04-01 08:34:10 +00: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-02 22:42:35 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
dst[i] = FFMIN(val >> 3, (1 << 19) - 1); // the cubic equation does overflow ...
|
2011-08-02 22:42:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-19 17:48:21 +00:00
|
|
|
// FIXME all pal and rgb srcFormats could do this conversion as well
|
2012-04-01 08:34:10 +00:00
|
|
|
// FIXME all scalers more complex than bilinear could do half of this transform
|
2011-06-04 04:31:35 +00:00
|
|
|
static void chrRangeToJpeg_c(int16_t *dstU, int16_t *dstV, int width)
|
2011-06-03 05:34:12 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 08:34:10 +00:00
|
|
|
dstU[i] = (FFMIN(dstU[i], 30775) * 4663 - 9289992) >> 12; // -264
|
|
|
|
dstV[i] = (FFMIN(dstV[i], 30775) * 4663 - 9289992) >> 12; // -264
|
2007-04-29 13:39:27 +00:00
|
|
|
}
|
2002-06-22 08:49:45 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-04 04:31:35 +00:00
|
|
|
static void chrRangeFromJpeg_c(int16_t *dstU, int16_t *dstV, int width)
|
2009-08-16 21:11:28 +00:00
|
|
|
{
|
2011-06-03 05:34:12 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++) {
|
2012-04-01 08:34:10 +00:00
|
|
|
dstU[i] = (dstU[i] * 1799 + 4081085) >> 11; // 1469
|
|
|
|
dstV[i] = (dstV[i] * 1799 + 4081085) >> 11; // 1469
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2002-02-10 00:43:31 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-04 04:31:35 +00:00
|
|
|
static void lumRangeToJpeg_c(int16_t *dst, int width)
|
2009-08-16 21:11:28 +00:00
|
|
|
{
|
2011-06-03 05:34:12 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++)
|
2012-04-01 08:34:10 +00:00
|
|
|
dst[i] = (FFMIN(dst[i], 30189) * 19077 - 39057361) >> 14;
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-04 04:31:35 +00:00
|
|
|
static void lumRangeFromJpeg_c(int16_t *dst, int width)
|
2011-06-03 05:34:12 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < width; i++)
|
2012-04-01 08:34:10 +00:00
|
|
|
dst[i] = (dst[i] * 14071 + 33561947) >> 14;
|
2002-06-27 23:48:53 +00:00
|
|
|
}
|
|
|
|
|
2011-06-29 16:39:43 +00: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 08:34:10 +00: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 16:39:43 +00:00
|
|
|
}
|
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-29 16:39:43 +00: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 08:34:10 +00:00
|
|
|
dstU[i] = (dstU[i] * 1799 + (4081085 << 4)) >> 11; // 1469
|
|
|
|
dstV[i] = (dstV[i] * 1799 + (4081085 << 4)) >> 11; // 1469
|
2011-06-29 16:39:43 +00:00
|
|
|
}
|
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-29 16:39:43 +00:00
|
|
|
static void lumRangeToJpeg16_c(int16_t *_dst, int width)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int32_t *dst = (int32_t *) _dst;
|
2014-03-24 04:01:32 +00:00
|
|
|
for (i = 0; i < width; i++) {
|
|
|
|
dst[i] = ((int)(FFMIN(dst[i], 30189 << 4) * 4769U - (39057361 << 2))) >> 12;
|
|
|
|
}
|
2011-06-29 16:39:43 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
|
2011-06-29 16:39:43 +00: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 03:28:13 +00:00
|
|
|
dst[i] = (dst[i]*(14071/4) + (33561947<<4)/4)>>12;
|
2011-06-29 16:39:43 +00:00
|
|
|
}
|
|
|
|
|
2002-01-20 05:30:23 +00:00
|
|
|
|
2011-06-03 05:34:12 +00:00
|
|
|
#define DEBUG_SWSCALE_BUFFERS 0
|
2012-04-01 08:34:10 +00:00
|
|
|
#define DEBUG_BUFFERS(...) \
|
|
|
|
if (DEBUG_SWSCALE_BUFFERS) \
|
|
|
|
av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2013-08-25 15:30:05 +00:00
|
|
|
static int swscale(SwsContext *c, const uint8_t *src[],
|
2011-06-03 05:34:13 +00:00
|
|
|
int srcStride[], int srcSliceY,
|
2012-04-01 08:34:10 +00:00
|
|
|
int srcSliceH, uint8_t *dst[], int dstStride[])
|
2009-08-16 21:11:28 +00:00
|
|
|
{
|
2012-04-01 08:34:10 +00:00
|
|
|
/* load a few things into local vars to make the code more readable?
|
|
|
|
* and faster */
|
|
|
|
const int dstW = c->dstW;
|
|
|
|
const int dstH = c->dstH;
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2012-10-06 10:10:34 +00:00
|
|
|
const enum AVPixelFormat dstFormat = c->dstFormat;
|
2012-04-01 08:34:10 +00:00
|
|
|
const int flags = c->flags;
|
|
|
|
int32_t *vLumFilterPos = c->vLumFilterPos;
|
|
|
|
int32_t *vChrFilterPos = c->vChrFilterPos;
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
const int vLumFilterSize = c->vLumFilterSize;
|
|
|
|
const int vChrFilterSize = c->vChrFilterSize;
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
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;
|
2013-01-25 20:51:25 +00:00
|
|
|
yuv2anyX_fn yuv2anyX = c->yuv2anyX;
|
2013-05-07 14:31:02 +00:00
|
|
|
const int chrSrcSliceY = srcSliceY >> c->chrSrcVSubSample;
|
2016-01-27 15:19:38 +00:00
|
|
|
const int chrSrcSliceH = AV_CEIL_RSHIFT(srcSliceH, c->chrSrcVSubSample);
|
2016-11-09 19:45:33 +00:00
|
|
|
int should_dither = isNBPS(c->srcFormat) ||
|
2012-04-01 08:34:10 +00:00
|
|
|
is16BPS(c->srcFormat);
|
2011-06-03 05:34:12 +00:00
|
|
|
int lastDstY;
|
|
|
|
|
|
|
|
/* vars which will change and which we need to store back in the context */
|
2012-04-01 08:34:10 +00:00
|
|
|
int dstY = c->dstY;
|
|
|
|
int lastInLumBuf = c->lastInLumBuf;
|
|
|
|
int lastInChrBuf = c->lastInChrBuf;
|
2015-04-17 20:08:42 +00:00
|
|
|
|
2015-08-17 20:03:20 +00:00
|
|
|
int lumStart = 0;
|
|
|
|
int lumEnd = c->descIndex[0];
|
|
|
|
int chrStart = lumEnd;
|
|
|
|
int chrEnd = c->descIndex[1];
|
2015-08-18 14:47:55 +00:00
|
|
|
int vStart = chrEnd;
|
|
|
|
int vEnd = c->numDesc;
|
2015-08-17 20:03:20 +00:00
|
|
|
SwsSlice *src_slice = &c->slice[lumStart];
|
2015-08-18 14:47:55 +00:00
|
|
|
SwsSlice *hout_slice = &c->slice[c->numSlice-2];
|
|
|
|
SwsSlice *vout_slice = &c->slice[c->numSlice-1];
|
2015-08-17 20:03:20 +00:00
|
|
|
SwsFilterDescriptor *desc = c->desc;
|
2015-09-04 21:11:21 +00:00
|
|
|
|
2016-03-28 16:25:18 +00:00
|
|
|
int needAlpha = c->needAlpha;
|
|
|
|
|
2015-08-17 20:07:53 +00:00
|
|
|
int hasLumHoles = 1;
|
|
|
|
int hasChrHoles = 1;
|
2015-08-17 20:03:20 +00:00
|
|
|
|
2011-06-03 05:34:12 +00:00
|
|
|
if (isPacked(c->srcFormat)) {
|
2012-04-01 08:34:10 +00:00
|
|
|
src[1] =
|
|
|
|
src[2] =
|
|
|
|
src[3] = src[0];
|
|
|
|
srcStride[1] =
|
|
|
|
srcStride[2] =
|
|
|
|
srcStride[3] = srcStride[0];
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2020-01-21 21:52:19 +00:00
|
|
|
srcStride[1] *= 1 << c->vChrDrop;
|
|
|
|
srcStride[2] *= 1 << c->vChrDrop;
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2013-08-25 15:30:05 +00:00
|
|
|
DEBUG_BUFFERS("swscale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",
|
2012-04-01 08:34:10 +00: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 05:34:12 +00:00
|
|
|
DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",
|
2012-04-01 08:34:10 +00:00
|
|
|
srcSliceY, srcSliceH, dstY, dstH);
|
2016-03-28 16:25:18 +00:00
|
|
|
DEBUG_BUFFERS("vLumFilterSize: %d vChrFilterSize: %d\n",
|
|
|
|
vLumFilterSize, vChrFilterSize);
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2014-06-18 02:24:31 +00:00
|
|
|
if (dstStride[0]&15 || dstStride[1]&15 ||
|
|
|
|
dstStride[2]&15 || dstStride[3]&15) {
|
2012-04-01 08:34:10 +00:00
|
|
|
static int warnedAlready = 0; // FIXME maybe move this into the context
|
2011-06-03 05:34:12 +00:00
|
|
|
if (flags & SWS_PRINT_INFO && !warnedAlready) {
|
2012-04-01 08:34:10 +00:00
|
|
|
av_log(c, AV_LOG_WARNING,
|
|
|
|
"Warning: dstStride is not aligned!\n"
|
2011-06-03 05:34:12 +00:00
|
|
|
" ->cannot do aligned memory accesses anymore\n");
|
2012-04-01 08:34:10 +00:00
|
|
|
warnedAlready = 1;
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-16 11:08:16 +00:00
|
|
|
|
2014-06-18 02:24:31 +00:00
|
|
|
if ( (uintptr_t)dst[0]&15 || (uintptr_t)dst[1]&15 || (uintptr_t)dst[2]&15
|
|
|
|
|| (uintptr_t)src[0]&15 || (uintptr_t)src[1]&15 || (uintptr_t)src[2]&15
|
|
|
|
|| dstStride[0]&15 || dstStride[1]&15 || dstStride[2]&15 || dstStride[3]&15
|
|
|
|
|| srcStride[0]&15 || srcStride[1]&15 || srcStride[2]&15 || srcStride[3]&15
|
2011-10-31 00:36:02 +00:00
|
|
|
) {
|
|
|
|
static int warnedAlready=0;
|
|
|
|
int cpu_flags = av_get_cpu_flags();
|
2012-08-19 17:19:19 +00:00
|
|
|
if (HAVE_MMXEXT && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){
|
2017-09-21 23:10:56 +00:00
|
|
|
av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speed loss\n");
|
2011-10-31 00:36:02 +00:00
|
|
|
warnedAlready=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-03 05:34:12 +00:00
|
|
|
/* Note the user might start scaling the picture in the middle so this
|
2012-04-01 08:34:10 +00:00
|
|
|
* will not get executed. This is not really intended but works
|
|
|
|
* currently, so people might do it. */
|
|
|
|
if (srcSliceY == 0) {
|
|
|
|
dstY = 0;
|
|
|
|
lastInLumBuf = -1;
|
|
|
|
lastInChrBuf = -1;
|
2009-04-21 00:01:59 +00:00
|
|
|
}
|
|
|
|
|
2011-07-05 19:49:11 +00:00
|
|
|
if (!should_dither) {
|
2013-08-15 11:29:01 +00:00
|
|
|
c->chrDither8 = c->lumDither8 = sws_pb_64;
|
2011-07-05 19:49:11 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00:00
|
|
|
lastDstY = dstY;
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,
|
|
|
|
yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, c->use_mmx_vfilter);
|
2015-08-17 20:03:20 +00:00
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
ff_init_slice_from_src(src_slice, (uint8_t**)src, srcStride, c->srcW,
|
2015-10-13 16:32:07 +00:00
|
|
|
srcSliceY, srcSliceH, chrSrcSliceY, chrSrcSliceH, 1);
|
2015-08-18 14:47:55 +00:00
|
|
|
|
|
|
|
ff_init_slice_from_src(vout_slice, (uint8_t**)dst, dstStride, c->dstW,
|
|
|
|
dstY, dstH, dstY >> c->chrDstVSubSample,
|
2016-01-27 15:19:38 +00:00
|
|
|
AV_CEIL_RSHIFT(dstH, c->chrDstVSubSample), 0);
|
2015-09-25 15:17:43 +00:00
|
|
|
if (srcSliceY == 0) {
|
|
|
|
hout_slice->plane[0].sliceY = lastInLumBuf + 1;
|
|
|
|
hout_slice->plane[1].sliceY = lastInChrBuf + 1;
|
|
|
|
hout_slice->plane[2].sliceY = lastInChrBuf + 1;
|
|
|
|
hout_slice->plane[3].sliceY = lastInLumBuf + 1;
|
|
|
|
|
|
|
|
hout_slice->plane[0].sliceH =
|
|
|
|
hout_slice->plane[1].sliceH =
|
|
|
|
hout_slice->plane[2].sliceH =
|
|
|
|
hout_slice->plane[3].sliceH = 0;
|
|
|
|
hout_slice->width = dstW;
|
|
|
|
}
|
2015-08-17 20:03:20 +00:00
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
for (; dstY < dstH; dstY++) {
|
|
|
|
const int chrDstY = dstY >> c->chrDstVSubSample;
|
2011-10-23 17:19:57 +00:00
|
|
|
int use_mmx_vfilter= c->use_mmx_vfilter;
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2012-04-01 08:34:10 +00: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 16:27:43 +00: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 05:34:12 +00:00
|
|
|
int enough_lines;
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2015-08-17 20:03:20 +00:00
|
|
|
int i;
|
2015-08-17 20:07:53 +00:00
|
|
|
int posY, cPosY, firstPosY, lastPosY, firstCPosY, lastCPosY;
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2012-04-01 08:34:10 +00:00
|
|
|
// handle holes (FAST_BILINEAR & weird filters)
|
2015-08-17 20:03:20 +00:00
|
|
|
if (firstLumSrcY > lastInLumBuf) {
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2015-08-17 20:07:53 +00:00
|
|
|
hasLumHoles = lastInLumBuf != firstLumSrcY - 1;
|
|
|
|
if (hasLumHoles) {
|
2015-09-20 21:03:49 +00:00
|
|
|
hout_slice->plane[0].sliceY = firstLumSrcY;
|
|
|
|
hout_slice->plane[3].sliceY = firstLumSrcY;
|
2015-08-18 14:47:55 +00:00
|
|
|
hout_slice->plane[0].sliceH =
|
|
|
|
hout_slice->plane[3].sliceH = 0;
|
2015-08-17 20:07:53 +00:00
|
|
|
}
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
lastInLumBuf = firstLumSrcY - 1;
|
2015-08-17 20:03:20 +00:00
|
|
|
}
|
|
|
|
if (firstChrSrcY > lastInChrBuf) {
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2015-08-17 20:07:53 +00:00
|
|
|
hasChrHoles = lastInChrBuf != firstChrSrcY - 1;
|
|
|
|
if (hasChrHoles) {
|
2015-09-20 21:03:49 +00:00
|
|
|
hout_slice->plane[1].sliceY = firstChrSrcY;
|
|
|
|
hout_slice->plane[2].sliceY = firstChrSrcY;
|
2015-08-18 14:47:55 +00:00
|
|
|
hout_slice->plane[1].sliceH =
|
|
|
|
hout_slice->plane[2].sliceH = 0;
|
2015-08-17 20:07:53 +00:00
|
|
|
}
|
2016-03-28 16:25:18 +00:00
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
lastInChrBuf = firstChrSrcY - 1;
|
2015-08-17 20:03:20 +00:00
|
|
|
}
|
2011-06-03 05:34:12 +00:00
|
|
|
|
|
|
|
DEBUG_BUFFERS("dstY: %d\n", dstY);
|
|
|
|
DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",
|
2012-04-01 08:34:10 +00:00
|
|
|
firstLumSrcY, lastLumSrcY, lastInLumBuf);
|
2011-06-03 05:34:12 +00:00
|
|
|
DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",
|
2012-04-01 08:34:10 +00:00
|
|
|
firstChrSrcY, lastChrSrcY, lastInChrBuf);
|
2011-06-03 05:34:12 +00:00
|
|
|
|
|
|
|
// Do we have enough lines in this slice to output the dstY line
|
2012-04-01 08:34:10 +00:00
|
|
|
enough_lines = lastLumSrcY2 < srcSliceY + srcSliceH &&
|
2016-01-27 15:19:38 +00:00
|
|
|
lastChrSrcY < AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample);
|
2011-06-03 05:34:12 +00:00
|
|
|
|
|
|
|
if (!enough_lines) {
|
|
|
|
lastLumSrcY = srcSliceY + srcSliceH - 1;
|
|
|
|
lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;
|
|
|
|
DEBUG_BUFFERS("buffering slice: lastLumSrcY %d lastChrSrcY %d\n",
|
2012-04-01 08:34:10 +00:00
|
|
|
lastLumSrcY, lastChrSrcY);
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2010-08-18 19:37:37 +00:00
|
|
|
|
2016-06-09 00:38:49 +00:00
|
|
|
av_assert0((lastLumSrcY - firstLumSrcY + 1) <= hout_slice->plane[0].available_lines);
|
|
|
|
av_assert0((lastChrSrcY - firstChrSrcY + 1) <= hout_slice->plane[1].available_lines);
|
|
|
|
|
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
posY = hout_slice->plane[0].sliceY + hout_slice->plane[0].sliceH;
|
2015-08-17 20:07:53 +00:00
|
|
|
if (posY <= lastLumSrcY && !hasLumHoles) {
|
|
|
|
firstPosY = FFMAX(firstLumSrcY, posY);
|
2016-06-09 00:38:49 +00:00
|
|
|
lastPosY = FFMIN(firstLumSrcY + hout_slice->plane[0].available_lines - 1, srcSliceY + srcSliceH - 1);
|
2015-08-17 20:07:53 +00:00
|
|
|
} else {
|
2016-09-08 18:57:40 +00:00
|
|
|
firstPosY = posY;
|
2015-08-17 20:07:53 +00:00
|
|
|
lastPosY = lastLumSrcY;
|
|
|
|
}
|
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
cPosY = hout_slice->plane[1].sliceY + hout_slice->plane[1].sliceH;
|
2015-08-17 20:07:53 +00:00
|
|
|
if (cPosY <= lastChrSrcY && !hasChrHoles) {
|
|
|
|
firstCPosY = FFMAX(firstChrSrcY, cPosY);
|
2016-06-09 00:38:49 +00:00
|
|
|
lastCPosY = FFMIN(firstChrSrcY + hout_slice->plane[1].available_lines - 1, AV_CEIL_RSHIFT(srcSliceY + srcSliceH, c->chrSrcVSubSample) - 1);
|
2015-08-17 20:07:53 +00:00
|
|
|
} else {
|
2016-09-08 18:57:40 +00:00
|
|
|
firstCPosY = cPosY;
|
2015-08-17 20:07:53 +00:00
|
|
|
lastCPosY = lastChrSrcY;
|
|
|
|
}
|
|
|
|
|
2015-08-18 14:47:55 +00:00
|
|
|
ff_rotate_slice(hout_slice, lastPosY, lastCPosY);
|
2015-08-17 20:03:20 +00:00
|
|
|
|
2015-08-17 20:07:53 +00:00
|
|
|
if (posY < lastLumSrcY + 1) {
|
2015-08-17 20:03:20 +00:00
|
|
|
for (i = lumStart; i < lumEnd; ++i)
|
2015-08-17 20:07:53 +00:00
|
|
|
desc[i].process(c, &desc[i], firstPosY, lastPosY - firstPosY + 1);
|
|
|
|
}
|
|
|
|
|
2015-08-17 20:03:20 +00:00
|
|
|
lastInLumBuf = lastLumSrcY;
|
|
|
|
|
2015-08-17 20:07:53 +00:00
|
|
|
if (cPosY < lastChrSrcY + 1) {
|
2015-08-17 20:03:20 +00:00
|
|
|
for (i = chrStart; i < chrEnd; ++i)
|
2015-08-17 20:07:53 +00:00
|
|
|
desc[i].process(c, &desc[i], firstCPosY, lastCPosY - firstCPosY + 1);
|
|
|
|
}
|
|
|
|
|
2015-08-17 20:03:20 +00:00
|
|
|
lastInChrBuf = lastChrSrcY;
|
|
|
|
|
2011-06-03 05:34:12 +00:00
|
|
|
if (!enough_lines)
|
2012-04-01 08:34:10 +00:00
|
|
|
break; // we can't output a dstY line so let's try with the next slice
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2012-08-28 12:53:33 +00:00
|
|
|
#if HAVE_MMX_INLINE
|
2020-04-01 07:32:15 +00:00
|
|
|
ff_updateMMXDitherTables(c, dstY);
|
2011-06-03 05:34:12 +00:00
|
|
|
#endif
|
2011-07-05 19:49:11 +00:00
|
|
|
if (should_dither) {
|
2013-08-15 11:38:12 +00:00
|
|
|
c->chrDither8 = ff_dither_8x8_128[chrDstY & 7];
|
|
|
|
c->lumDither8 = ff_dither_8x8_128[dstY & 7];
|
2011-07-05 19:49:11 +00:00
|
|
|
}
|
2012-04-01 08:34:10 +00: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,
|
2013-01-25 20:51:25 +00:00
|
|
|
&yuv2packed1, &yuv2packed2, &yuv2packedX, &yuv2anyX);
|
2011-10-23 17:19:57 +00:00
|
|
|
use_mmx_vfilter= 0;
|
2015-08-18 14:47:55 +00:00
|
|
|
ff_init_vscale_pfn(c, yuv2plane1, yuv2planeX, yuv2nv12cX,
|
|
|
|
yuv2packed1, yuv2packed2, yuv2packedX, yuv2anyX, use_mmx_vfilter);
|
2011-06-06 02:54:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2015-08-18 14:47:55 +00:00
|
|
|
for (i = vStart; i < vEnd; ++i)
|
|
|
|
desc[i].process(c, &desc[i], dstY, 1);
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2010-08-18 19:37:37 +00:00
|
|
|
}
|
2016-03-28 16:25:18 +00:00
|
|
|
if (isPlanar(dstFormat) && isALPHA(dstFormat) && !needAlpha) {
|
2012-10-29 18:07:01 +00:00
|
|
|
int length = dstW;
|
|
|
|
int height = dstY - lastDstY;
|
|
|
|
|
2012-10-30 17:40:55 +00:00
|
|
|
if (is16BPS(dstFormat) || isNBPS(dstFormat)) {
|
2012-10-29 18:07:01 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
|
2012-10-30 17:40:55 +00:00
|
|
|
fillPlane16(dst[3], dstStride[3], length, height, lastDstY,
|
2015-09-08 13:43:03 +00:00
|
|
|
1, desc->comp[3].depth,
|
2012-10-30 17:40:55 +00:00
|
|
|
isBE(dstFormat));
|
2020-05-03 23:10:04 +00:00
|
|
|
} else if (is32BPS(dstFormat)) {
|
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
|
|
|
|
fillPlane32(dst[3], dstStride[3], length, height, lastDstY,
|
|
|
|
1, desc->comp[3].depth,
|
|
|
|
isBE(dstFormat), desc->flags & AV_PIX_FMT_FLAG_FLOAT);
|
2012-10-29 18:07:01 +00:00
|
|
|
} else
|
|
|
|
fillPlane(dst[3], dstStride[3], length, height, lastDstY, 255);
|
|
|
|
}
|
2011-06-03 05:34:12 +00:00
|
|
|
|
2012-09-04 06:30:16 +00:00
|
|
|
#if HAVE_MMXEXT_INLINE
|
2012-07-08 16:42:12 +00:00
|
|
|
if (av_get_cpu_flags() & AV_CPU_FLAG_MMXEXT)
|
2012-04-01 08:34:10 +00:00
|
|
|
__asm__ volatile ("sfence" ::: "memory");
|
2011-06-03 05:34:12 +00:00
|
|
|
#endif
|
|
|
|
emms_c();
|
|
|
|
|
|
|
|
/* store changed local vars back in the context */
|
2012-04-01 08:34:10 +00:00
|
|
|
c->dstY = dstY;
|
|
|
|
c->lastInLumBuf = lastInLumBuf;
|
|
|
|
c->lastInChrBuf = lastInChrBuf;
|
2011-06-03 05:34:12 +00:00
|
|
|
|
|
|
|
return dstY - lastDstY;
|
2010-08-18 19:37:37 +00:00
|
|
|
}
|
|
|
|
|
2014-04-14 21:18:21 +00:00
|
|
|
av_cold void ff_sws_init_range_convert(SwsContext *c)
|
|
|
|
{
|
|
|
|
c->lumConvertRange = NULL;
|
|
|
|
c->chrConvertRange = NULL;
|
|
|
|
if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {
|
|
|
|
if (c->dstBpc <= 14) {
|
|
|
|
if (c->srcRange) {
|
|
|
|
c->lumConvertRange = lumRangeFromJpeg_c;
|
|
|
|
c->chrConvertRange = chrRangeFromJpeg_c;
|
|
|
|
} else {
|
|
|
|
c->lumConvertRange = lumRangeToJpeg_c;
|
|
|
|
c->chrConvertRange = chrRangeToJpeg_c;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (c->srcRange) {
|
|
|
|
c->lumConvertRange = lumRangeFromJpeg16_c;
|
|
|
|
c->chrConvertRange = chrRangeFromJpeg16_c;
|
|
|
|
} else {
|
|
|
|
c->lumConvertRange = lumRangeToJpeg16_c;
|
|
|
|
c->chrConvertRange = chrRangeToJpeg16_c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-25 15:30:05 +00:00
|
|
|
static av_cold void sws_init_swscale(SwsContext *c)
|
2009-08-16 21:11:28 +00:00
|
|
|
{
|
2012-10-06 10:10:34 +00:00
|
|
|
enum AVPixelFormat srcFormat = c->srcFormat;
|
2008-09-04 20:46:36 +00:00
|
|
|
|
2012-02-01 15:38:56 +00:00
|
|
|
ff_sws_init_output_funcs(c, &c->yuv2plane1, &c->yuv2planeX,
|
|
|
|
&c->yuv2nv12cX, &c->yuv2packed1,
|
2013-01-25 20:51:25 +00:00
|
|
|
&c->yuv2packed2, &c->yuv2packedX, &c->yuv2anyX);
|
2007-04-29 13:39:27 +00:00
|
|
|
|
2012-02-01 15:38:55 +00:00
|
|
|
ff_sws_init_input_funcs(c);
|
2007-04-15 00:53:32 +00:00
|
|
|
|
2011-08-02 22:42:35 +00:00
|
|
|
if (c->srcBpc == 8) {
|
2012-07-03 02:10:11 +00:00
|
|
|
if (c->dstBpc <= 14) {
|
2011-08-03 18:25:01 +00:00
|
|
|
c->hyScale = c->hcScale = hScale8To15_c;
|
2011-08-02 22:42:35 +00:00
|
|
|
if (c->flags & SWS_FAST_BILINEAR) {
|
2014-07-19 02:57:47 +00:00
|
|
|
c->hyscale_fast = ff_hyscale_fast_c;
|
|
|
|
c->hcscale_fast = ff_hcscale_fast_c;
|
2011-08-02 22:42:35 +00:00
|
|
|
}
|
2011-06-03 05:34:12 +00:00
|
|
|
} else {
|
2011-08-03 18:25:01 +00:00
|
|
|
c->hyScale = c->hcScale = hScale8To19_c;
|
2011-06-03 05:34:12 +00:00
|
|
|
}
|
2011-06-29 16:39:43 +00:00
|
|
|
} else {
|
2012-07-03 02:10:11 +00:00
|
|
|
c->hyScale = c->hcScale = c->dstBpc > 14 ? hScale16To19_c
|
2012-04-01 08:34:10 +00:00
|
|
|
: hScale16To15_c;
|
2011-08-02 22:42:35 +00:00
|
|
|
}
|
2011-06-29 16:39:43 +00:00
|
|
|
|
2014-04-14 21:18:21 +00:00
|
|
|
ff_sws_init_range_convert(c);
|
2003-03-27 16:04:53 +00:00
|
|
|
|
2011-06-03 05:34:12 +00:00
|
|
|
if (!(isGray(srcFormat) || isGray(c->dstFormat) ||
|
2012-10-06 10:10:34 +00:00
|
|
|
srcFormat == AV_PIX_FMT_MONOBLACK || srcFormat == AV_PIX_FMT_MONOWHITE))
|
2011-06-03 05:34:12 +00:00
|
|
|
c->needs_hcscale = 1;
|
2003-02-23 22:05:55 +00:00
|
|
|
}
|
2010-06-01 19:35:16 +00:00
|
|
|
|
2010-01-24 02:08:22 +00:00
|
|
|
SwsFunc ff_getSwsFunc(SwsContext *c)
|
2010-06-01 19:35:16 +00:00
|
|
|
{
|
2013-08-25 15:30:05 +00:00
|
|
|
sws_init_swscale(c);
|
2010-06-01 19:35:16 +00:00
|
|
|
|
2012-10-10 23:06:04 +00:00
|
|
|
if (ARCH_PPC)
|
|
|
|
ff_sws_init_swscale_ppc(c);
|
2012-10-12 17:54:45 +00:00
|
|
|
if (ARCH_X86)
|
|
|
|
ff_sws_init_swscale_x86(c);
|
2016-03-18 15:39:34 +00:00
|
|
|
if (ARCH_AARCH64)
|
|
|
|
ff_sws_init_swscale_aarch64(c);
|
2016-04-07 14:52:00 +00:00
|
|
|
if (ARCH_ARM)
|
|
|
|
ff_sws_init_swscale_arm(c);
|
2010-06-01 19:35:16 +00:00
|
|
|
|
2013-08-25 15:30:05 +00:00
|
|
|
return swscale;
|
2010-06-01 19:35:16 +00:00
|
|
|
}
|
2012-09-30 21:09:45 +00:00
|
|
|
|
2015-03-15 23:14:30 +00:00
|
|
|
static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
|
2012-09-30 21:09:45 +00:00
|
|
|
{
|
|
|
|
if (!isALPHA(format))
|
|
|
|
src[3] = NULL;
|
|
|
|
if (!isPlanar(format)) {
|
|
|
|
src[3] = src[2] = NULL;
|
|
|
|
|
|
|
|
if (!usePal(format))
|
|
|
|
src[1] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-08 18:54:00 +00:00
|
|
|
static int check_image_pointers(const uint8_t * const data[4], enum AVPixelFormat pix_fmt,
|
2012-09-30 21:09:45 +00:00
|
|
|
const int linesizes[4])
|
|
|
|
{
|
2012-10-12 13:52:55 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
|
2012-09-30 21:09:45 +00:00
|
|
|
int i;
|
|
|
|
|
2015-06-12 12:39:28 +00:00
|
|
|
av_assert2(desc);
|
|
|
|
|
2012-09-30 21:09:45 +00:00
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int plane = desc->comp[i].plane;
|
|
|
|
if (!data[plane] || !linesizes[plane])
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-04-28 17:28:42 +00:00
|
|
|
static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst,
|
|
|
|
const uint16_t *src, int stride, int h)
|
|
|
|
{
|
|
|
|
int xp,yp;
|
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
|
|
|
|
|
|
|
|
for (yp=0; yp<h; yp++) {
|
|
|
|
for (xp=0; xp+2<stride; xp+=3) {
|
|
|
|
int x, y, z, r, g, b;
|
|
|
|
|
2013-05-15 09:23:14 +00:00
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_BE) {
|
2013-04-28 17:28:42 +00:00
|
|
|
x = AV_RB16(src + xp + 0);
|
|
|
|
y = AV_RB16(src + xp + 1);
|
|
|
|
z = AV_RB16(src + xp + 2);
|
|
|
|
} else {
|
|
|
|
x = AV_RL16(src + xp + 0);
|
|
|
|
y = AV_RL16(src + xp + 1);
|
|
|
|
z = AV_RL16(src + xp + 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
x = c->xyzgamma[x>>4];
|
|
|
|
y = c->xyzgamma[y>>4];
|
|
|
|
z = c->xyzgamma[z>>4];
|
|
|
|
|
|
|
|
// convert from XYZlinear to sRGBlinear
|
|
|
|
r = c->xyz2rgb_matrix[0][0] * x +
|
|
|
|
c->xyz2rgb_matrix[0][1] * y +
|
|
|
|
c->xyz2rgb_matrix[0][2] * z >> 12;
|
|
|
|
g = c->xyz2rgb_matrix[1][0] * x +
|
|
|
|
c->xyz2rgb_matrix[1][1] * y +
|
|
|
|
c->xyz2rgb_matrix[1][2] * z >> 12;
|
|
|
|
b = c->xyz2rgb_matrix[2][0] * x +
|
2013-04-28 17:57:45 +00:00
|
|
|
c->xyz2rgb_matrix[2][1] * y +
|
2013-04-28 17:28:42 +00:00
|
|
|
c->xyz2rgb_matrix[2][2] * z >> 12;
|
|
|
|
|
|
|
|
// limit values to 12-bit depth
|
2015-02-21 13:49:17 +00:00
|
|
|
r = av_clip_uintp2(r, 12);
|
|
|
|
g = av_clip_uintp2(g, 12);
|
|
|
|
b = av_clip_uintp2(b, 12);
|
2013-04-28 17:28:42 +00:00
|
|
|
|
|
|
|
// convert from sRGBlinear to RGB and scale from 12bit to 16bit
|
2013-05-15 09:23:14 +00:00
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_BE) {
|
2013-04-28 17:28:42 +00:00
|
|
|
AV_WB16(dst + xp + 0, c->rgbgamma[r] << 4);
|
|
|
|
AV_WB16(dst + xp + 1, c->rgbgamma[g] << 4);
|
|
|
|
AV_WB16(dst + xp + 2, c->rgbgamma[b] << 4);
|
|
|
|
} else {
|
|
|
|
AV_WL16(dst + xp + 0, c->rgbgamma[r] << 4);
|
|
|
|
AV_WL16(dst + xp + 1, c->rgbgamma[g] << 4);
|
|
|
|
AV_WL16(dst + xp + 2, c->rgbgamma[b] << 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
src += stride;
|
|
|
|
dst += stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-14 03:30:38 +00:00
|
|
|
static void rgb48Toxyz12(struct SwsContext *c, uint16_t *dst,
|
|
|
|
const uint16_t *src, int stride, int h)
|
|
|
|
{
|
|
|
|
int xp,yp;
|
2014-01-10 16:23:04 +00:00
|
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
|
2013-07-14 03:30:38 +00:00
|
|
|
|
|
|
|
for (yp=0; yp<h; yp++) {
|
|
|
|
for (xp=0; xp+2<stride; xp+=3) {
|
|
|
|
int x, y, z, r, g, b;
|
|
|
|
|
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_BE) {
|
|
|
|
r = AV_RB16(src + xp + 0);
|
|
|
|
g = AV_RB16(src + xp + 1);
|
|
|
|
b = AV_RB16(src + xp + 2);
|
|
|
|
} else {
|
|
|
|
r = AV_RL16(src + xp + 0);
|
|
|
|
g = AV_RL16(src + xp + 1);
|
|
|
|
b = AV_RL16(src + xp + 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = c->rgbgammainv[r>>4];
|
|
|
|
g = c->rgbgammainv[g>>4];
|
|
|
|
b = c->rgbgammainv[b>>4];
|
|
|
|
|
|
|
|
// convert from sRGBlinear to XYZlinear
|
|
|
|
x = c->rgb2xyz_matrix[0][0] * r +
|
|
|
|
c->rgb2xyz_matrix[0][1] * g +
|
|
|
|
c->rgb2xyz_matrix[0][2] * b >> 12;
|
|
|
|
y = c->rgb2xyz_matrix[1][0] * r +
|
|
|
|
c->rgb2xyz_matrix[1][1] * g +
|
|
|
|
c->rgb2xyz_matrix[1][2] * b >> 12;
|
|
|
|
z = c->rgb2xyz_matrix[2][0] * r +
|
|
|
|
c->rgb2xyz_matrix[2][1] * g +
|
|
|
|
c->rgb2xyz_matrix[2][2] * b >> 12;
|
|
|
|
|
|
|
|
// limit values to 12-bit depth
|
2015-02-21 13:49:17 +00:00
|
|
|
x = av_clip_uintp2(x, 12);
|
|
|
|
y = av_clip_uintp2(y, 12);
|
|
|
|
z = av_clip_uintp2(z, 12);
|
2013-07-14 03:30:38 +00:00
|
|
|
|
|
|
|
// convert from XYZlinear to X'Y'Z' and scale from 12bit to 16bit
|
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_BE) {
|
|
|
|
AV_WB16(dst + xp + 0, c->xyzgammainv[x] << 4);
|
|
|
|
AV_WB16(dst + xp + 1, c->xyzgammainv[y] << 4);
|
|
|
|
AV_WB16(dst + xp + 2, c->xyzgammainv[z] << 4);
|
|
|
|
} else {
|
|
|
|
AV_WL16(dst + xp + 0, c->xyzgammainv[x] << 4);
|
|
|
|
AV_WL16(dst + xp + 1, c->xyzgammainv[y] << 4);
|
|
|
|
AV_WL16(dst + xp + 2, c->xyzgammainv[z] << 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
src += stride;
|
|
|
|
dst += stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-30 21:09:45 +00:00
|
|
|
/**
|
|
|
|
* swscale wrapper, so we don't need to export the SwsContext.
|
|
|
|
* Assumes planar YUV to be in YUV order instead of YVU.
|
|
|
|
*/
|
|
|
|
int attribute_align_arg sws_scale(struct SwsContext *c,
|
|
|
|
const uint8_t * const srcSlice[],
|
|
|
|
const int srcStride[], int srcSliceY,
|
|
|
|
int srcSliceH, uint8_t *const dst[],
|
|
|
|
const int dstStride[])
|
|
|
|
{
|
|
|
|
int i, ret;
|
2012-12-07 20:48:27 +00:00
|
|
|
const uint8_t *src2[4];
|
|
|
|
uint8_t *dst2[4];
|
2012-09-30 21:09:45 +00:00
|
|
|
uint8_t *rgb0_tmp = NULL;
|
2016-01-17 17:57:01 +00:00
|
|
|
int macro_height = isBayer(c->srcFormat) ? 2 : (1 << c->chrSrcVSubSample);
|
2016-09-02 14:35:36 +00:00
|
|
|
// copy strides, so they can safely be modified
|
2016-12-23 20:14:59 +00:00
|
|
|
int srcStride2[4];
|
|
|
|
int dstStride2[4];
|
2016-09-02 14:35:36 +00:00
|
|
|
int srcSliceY_internal = srcSliceY;
|
2012-09-30 21:09:45 +00:00
|
|
|
|
2014-04-15 23:55:08 +00:00
|
|
|
if (!srcStride || !dstStride || !dst || !srcSlice) {
|
2012-12-07 20:48:27 +00:00
|
|
|
av_log(c, AV_LOG_ERROR, "One of the input parameters to sws_scale() is NULL, please check the calling code\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2015-04-17 20:08:42 +00:00
|
|
|
|
2016-12-23 20:14:59 +00:00
|
|
|
for (i=0; i<4; i++) {
|
|
|
|
srcStride2[i] = srcStride[i];
|
|
|
|
dstStride2[i] = dstStride[i];
|
|
|
|
}
|
|
|
|
|
2016-01-17 17:57:01 +00:00
|
|
|
if ((srcSliceY & (macro_height-1)) ||
|
|
|
|
((srcSliceH& (macro_height-1)) && srcSliceY + srcSliceH != c->srcH) ||
|
|
|
|
srcSliceY + srcSliceH > c->srcH) {
|
|
|
|
av_log(c, AV_LOG_ERROR, "Slice parameters %d, %d are invalid\n", srcSliceY, srcSliceH);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2015-04-17 20:08:42 +00:00
|
|
|
if (c->gamma_flag && c->cascaded_context[0]) {
|
|
|
|
ret = sws_scale(c->cascaded_context[0],
|
|
|
|
srcSlice, srcStride, srcSliceY, srcSliceH,
|
|
|
|
c->cascaded_tmp, c->cascaded_tmpStride);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (c->cascaded_context[2])
|
|
|
|
ret = sws_scale(c->cascaded_context[1], (const uint8_t * const *)c->cascaded_tmp, c->cascaded_tmpStride, srcSliceY, srcSliceH, c->cascaded1_tmp, c->cascaded1_tmpStride);
|
|
|
|
else
|
|
|
|
ret = sws_scale(c->cascaded_context[1], (const uint8_t * const *)c->cascaded_tmp, c->cascaded_tmpStride, srcSliceY, srcSliceH, dst, dstStride);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (c->cascaded_context[2]) {
|
|
|
|
ret = sws_scale(c->cascaded_context[2],
|
|
|
|
(const uint8_t * const *)c->cascaded1_tmp, c->cascaded1_tmpStride, c->cascaded_context[1]->dstY - ret, c->cascaded_context[1]->dstY,
|
|
|
|
dst, dstStride);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-08 00:05:54 +00:00
|
|
|
if (c->cascaded_context[0] && srcSliceY == 0 && srcSliceH == c->cascaded_context[0]->srcH) {
|
|
|
|
ret = sws_scale(c->cascaded_context[0],
|
|
|
|
srcSlice, srcStride, srcSliceY, srcSliceH,
|
|
|
|
c->cascaded_tmp, c->cascaded_tmpStride);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
ret = sws_scale(c->cascaded_context[1],
|
|
|
|
(const uint8_t * const * )c->cascaded_tmp, c->cascaded_tmpStride, 0, c->cascaded_context[0]->dstH,
|
|
|
|
dst, dstStride);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-12-07 20:48:27 +00:00
|
|
|
memcpy(src2, srcSlice, sizeof(src2));
|
|
|
|
memcpy(dst2, dst, sizeof(dst2));
|
|
|
|
|
2012-09-30 21:09:45 +00:00
|
|
|
// do not mess up sliceDir if we have a "trailing" 0-size slice
|
|
|
|
if (srcSliceH == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!check_image_pointers(srcSlice, c->srcFormat, srcStride)) {
|
|
|
|
av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!check_image_pointers((const uint8_t* const*)dst, c->dstFormat, dstStride)) {
|
|
|
|
av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
|
|
|
|
av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (c->sliceDir == 0) {
|
|
|
|
if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (usePal(c->srcFormat)) {
|
|
|
|
for (i = 0; i < 256; i++) {
|
2014-04-12 23:26:49 +00:00
|
|
|
int r, g, b, y, u, v, a = 0xff;
|
2012-10-08 18:54:00 +00:00
|
|
|
if (c->srcFormat == AV_PIX_FMT_PAL8) {
|
2014-04-12 23:26:49 +00:00
|
|
|
uint32_t p = ((const uint32_t *)(srcSlice[1]))[i];
|
2012-09-30 21:09:45 +00:00
|
|
|
a = (p >> 24) & 0xFF;
|
|
|
|
r = (p >> 16) & 0xFF;
|
|
|
|
g = (p >> 8) & 0xFF;
|
|
|
|
b = p & 0xFF;
|
2012-10-08 18:54:00 +00:00
|
|
|
} else if (c->srcFormat == AV_PIX_FMT_RGB8) {
|
2012-09-30 21:09:45 +00:00
|
|
|
r = ( i >> 5 ) * 36;
|
|
|
|
g = ((i >> 2) & 7) * 36;
|
|
|
|
b = ( i & 3) * 85;
|
2012-10-08 18:54:00 +00:00
|
|
|
} else if (c->srcFormat == AV_PIX_FMT_BGR8) {
|
2012-09-30 21:09:45 +00:00
|
|
|
b = ( i >> 6 ) * 85;
|
|
|
|
g = ((i >> 3) & 7) * 36;
|
|
|
|
r = ( i & 7) * 36;
|
2012-10-08 18:54:00 +00:00
|
|
|
} else if (c->srcFormat == AV_PIX_FMT_RGB4_BYTE) {
|
2012-09-30 21:09:45 +00:00
|
|
|
r = ( i >> 3 ) * 255;
|
|
|
|
g = ((i >> 1) & 3) * 85;
|
|
|
|
b = ( i & 1) * 255;
|
2012-10-08 18:54:00 +00:00
|
|
|
} else if (c->srcFormat == AV_PIX_FMT_GRAY8 || c->srcFormat == AV_PIX_FMT_GRAY8A) {
|
2012-09-30 21:09:45 +00:00
|
|
|
r = g = b = i;
|
|
|
|
} else {
|
2012-10-08 18:54:00 +00:00
|
|
|
av_assert1(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
|
2012-09-30 21:09:45 +00:00
|
|
|
b = ( i >> 3 ) * 255;
|
|
|
|
g = ((i >> 1) & 3) * 85;
|
|
|
|
r = ( i & 1) * 255;
|
|
|
|
}
|
|
|
|
#define RGB2YUV_SHIFT 15
|
|
|
|
#define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
#define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
|
|
|
|
|
|
|
|
y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
|
|
|
|
u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
|
|
|
|
v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
|
2012-10-14 03:16:59 +00:00
|
|
|
c->pal_yuv[i]= y + (u<<8) + (v<<16) + ((unsigned)a<<24);
|
2012-09-30 21:09:45 +00:00
|
|
|
|
|
|
|
switch (c->dstFormat) {
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_BGR32:
|
2012-09-30 21:09:45 +00:00
|
|
|
#if !HAVE_BIGENDIAN
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_RGB24:
|
2012-09-30 21:09:45 +00:00
|
|
|
#endif
|
2012-10-14 03:16:59 +00:00
|
|
|
c->pal_rgb[i]= r + (g<<8) + (b<<16) + ((unsigned)a<<24);
|
2012-09-30 21:09:45 +00:00
|
|
|
break;
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_BGR32_1:
|
2012-09-30 21:09:45 +00:00
|
|
|
#if HAVE_BIGENDIAN
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_BGR24:
|
2012-09-30 21:09:45 +00:00
|
|
|
#endif
|
2012-10-14 03:16:59 +00:00
|
|
|
c->pal_rgb[i]= a + (r<<8) + (g<<16) + ((unsigned)b<<24);
|
2012-09-30 21:09:45 +00:00
|
|
|
break;
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_RGB32_1:
|
2012-09-30 21:09:45 +00:00
|
|
|
#if HAVE_BIGENDIAN
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_RGB24:
|
2012-09-30 21:09:45 +00:00
|
|
|
#endif
|
2012-10-14 03:16:59 +00:00
|
|
|
c->pal_rgb[i]= a + (b<<8) + (g<<16) + ((unsigned)r<<24);
|
2012-09-30 21:09:45 +00:00
|
|
|
break;
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_RGB32:
|
2012-09-30 21:09:45 +00:00
|
|
|
#if !HAVE_BIGENDIAN
|
2012-10-08 18:54:00 +00:00
|
|
|
case AV_PIX_FMT_BGR24:
|
2012-09-30 21:09:45 +00:00
|
|
|
#endif
|
|
|
|
default:
|
2012-10-14 03:16:59 +00:00
|
|
|
c->pal_rgb[i]= b + (g<<8) + (r<<16) + ((unsigned)a<<24);
|
2012-09-30 21:09:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c->src0Alpha && !c->dst0Alpha && isALPHA(c->dstFormat)) {
|
|
|
|
uint8_t *base;
|
|
|
|
int x,y;
|
|
|
|
rgb0_tmp = av_malloc(FFABS(srcStride[0]) * srcSliceH + 32);
|
2013-04-28 17:31:16 +00:00
|
|
|
if (!rgb0_tmp)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2012-09-30 21:09:45 +00:00
|
|
|
base = srcStride[0] < 0 ? rgb0_tmp - srcStride[0] * (srcSliceH-1) : rgb0_tmp;
|
|
|
|
for (y=0; y<srcSliceH; y++){
|
|
|
|
memcpy(base + srcStride[0]*y, src2[0] + srcStride[0]*y, 4*c->srcW);
|
|
|
|
for (x=c->src0Alpha-1; x<4*c->srcW; x+=4) {
|
|
|
|
base[ srcStride[0]*y + x] = 0xFF;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
src2[0] = base;
|
|
|
|
}
|
|
|
|
|
2013-04-28 17:28:42 +00:00
|
|
|
if (c->srcXYZ && !(c->dstXYZ && c->srcW==c->dstW && c->srcH==c->dstH)) {
|
|
|
|
uint8_t *base;
|
|
|
|
rgb0_tmp = av_malloc(FFABS(srcStride[0]) * srcSliceH + 32);
|
2013-04-28 17:31:16 +00:00
|
|
|
if (!rgb0_tmp)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2013-04-28 17:28:42 +00:00
|
|
|
base = srcStride[0] < 0 ? rgb0_tmp - srcStride[0] * (srcSliceH-1) : rgb0_tmp;
|
|
|
|
|
2013-05-10 18:35:49 +00:00
|
|
|
xyz12Torgb48(c, (uint16_t*)base, (const uint16_t*)src2[0], srcStride[0]/2, srcSliceH);
|
2013-04-28 17:28:42 +00:00
|
|
|
src2[0] = base;
|
|
|
|
}
|
|
|
|
|
2013-08-14 15:19:32 +00:00
|
|
|
if (!srcSliceY && (c->flags & SWS_BITEXACT) && c->dither == SWS_DITHER_ED && c->dither_error[0])
|
2013-01-18 22:01:08 +00:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
memset(c->dither_error[i], 0, sizeof(c->dither_error[0][0]) * (c->dstW+2));
|
|
|
|
|
2016-09-02 14:35:36 +00:00
|
|
|
if (c->sliceDir != 1) {
|
2012-09-30 21:09:45 +00:00
|
|
|
// slices go from bottom to top => we flip the image internally
|
2016-09-02 14:35:36 +00:00
|
|
|
for (i=0; i<4; i++) {
|
|
|
|
srcStride2[i] *= -1;
|
|
|
|
dstStride2[i] *= -1;
|
|
|
|
}
|
2012-09-30 21:09:45 +00:00
|
|
|
|
|
|
|
src2[0] += (srcSliceH - 1) * srcStride[0];
|
|
|
|
if (!usePal(c->srcFormat))
|
|
|
|
src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
|
|
|
|
src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
|
|
|
|
src2[3] += (srcSliceH - 1) * srcStride[3];
|
|
|
|
dst2[0] += ( c->dstH - 1) * dstStride[0];
|
|
|
|
dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
|
|
|
|
dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
|
|
|
|
dst2[3] += ( c->dstH - 1) * dstStride[3];
|
|
|
|
|
2016-09-02 14:35:36 +00:00
|
|
|
srcSliceY_internal = c->srcH-srcSliceY-srcSliceH;
|
2012-09-30 21:09:45 +00:00
|
|
|
}
|
2016-09-02 14:35:36 +00:00
|
|
|
reset_ptr(src2, c->srcFormat);
|
|
|
|
reset_ptr((void*)dst2, c->dstFormat);
|
|
|
|
|
|
|
|
/* reset slice direction at end of frame */
|
|
|
|
if (srcSliceY_internal + srcSliceH == c->srcH)
|
|
|
|
c->sliceDir = 0;
|
|
|
|
ret = c->swscale(c, src2, srcStride2, srcSliceY_internal, srcSliceH, dst2, dstStride2);
|
2012-09-30 21:09:45 +00:00
|
|
|
|
2013-07-14 03:30:38 +00:00
|
|
|
if (c->dstXYZ && !(c->srcXYZ && c->srcW==c->dstW && c->srcH==c->dstH)) {
|
2016-09-02 14:52:55 +00:00
|
|
|
int dstY = c->dstY ? c->dstY : srcSliceY + srcSliceH;
|
2016-09-06 23:44:16 +00:00
|
|
|
uint16_t *dst16 = (uint16_t*)(dst2[0] + (dstY - ret) * dstStride2[0]);
|
2016-09-02 14:52:55 +00:00
|
|
|
av_assert0(dstY >= ret);
|
|
|
|
av_assert0(ret >= 0);
|
|
|
|
av_assert0(c->dstH >= dstY);
|
|
|
|
|
2013-07-14 03:30:38 +00:00
|
|
|
/* replace on the same data */
|
2016-09-02 14:52:55 +00:00
|
|
|
rgb48Toxyz12(c, dst16, dst16, dstStride2[0]/2, ret);
|
2013-07-14 03:30:38 +00:00
|
|
|
}
|
|
|
|
|
2012-09-30 21:09:45 +00:00
|
|
|
av_free(rgb0_tmp);
|
|
|
|
return ret;
|
|
|
|
}
|