uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
const uint8_t *srcPtr = src[0];
- if (srcFormat == AV_PIX_FMT_Y400A) {
+ if (srcFormat == AV_PIX_FMT_YA8) {
switch (dstFormat) {
case AV_PIX_FMT_RGB32 : conv = gray8aToPacked32; break;
case AV_PIX_FMT_BGR32 : conv = gray8aToPacked32; break;
return srcSliceH;
}
+static int planarRgbToplanarRgbWrapper(SwsContext *c,
+ const uint8_t *src[], int srcStride[],
+ int srcSliceY, int srcSliceH,
+ uint8_t *dst[], int dstStride[])
+{
+ copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
+ dst[0], dstStride[0]);
+ copyPlane(src[1], srcStride[1], srcSliceY, srcSliceH, c->srcW,
+ dst[1], dstStride[1]);
+ copyPlane(src[2], srcStride[2], srcSliceY, srcSliceH, c->srcW,
+ dst[2], dstStride[2]);
+ if (dst[3])
+ fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
+
+ return srcSliceH;
+}
+
static void packedtogbr24p(const uint8_t *src, int srcStride,
uint8_t *dst[], int dstStride[], int srcSliceH,
int alpha_first, int inc_size, int width)
if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
!(srcStride[0] % srcBpp))
conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
- srcSliceH * srcStride[0]);
+ (srcSliceH - 1) * srcStride[0] + c->srcW * srcBpp);
else {
int i;
dstPtr += dstStride[0] * srcSliceY;
int height = (plane == 0 || plane == 3) ? srcSliceH: -((-srcSliceH) >> c->chrDstVSubSample);
const uint8_t *srcPtr = src[plane];
uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
+ int shiftonly = plane == 1 || plane == 2 || (!c->srcRange && plane == 0);
if (!dst[plane])
continue;
if (is9_OR_10BPS(c->dstFormat)) {
fill_plane9or10(dst[plane], dstStride[plane],
length, height, y, val,
- desc_dst->comp[plane].depth_minus1 + 1,
+ desc_dst->comp[plane].depth,
isBE(c->dstFormat));
} else
fillPlane(dst[plane], dstStride[plane], length, height, y,
val);
} else {
if (is9_OR_10BPS(c->srcFormat)) {
- const int src_depth = desc_src->comp[plane].depth_minus1 + 1;
- const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
+ const int src_depth = desc_src->comp[plane].depth;
+ const int dst_depth = desc_dst->comp[plane].depth;
const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
if (is16BPS(c->dstFormat)) {
uint16_t *dstPtr2 = (uint16_t *) dstPtr;
#define COPY9_OR_10TO16(rfunc, wfunc) \
- for (i = 0; i < height; i++) { \
- for (j = 0; j < length; j++) { \
- int srcpx = rfunc(&srcPtr2[j]); \
- wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
+ if (shiftonly) { \
+ for (i = 0; i < height; i++) { \
+ for (j = 0; j < length; j++) { \
+ int srcpx = rfunc(&srcPtr2[j]); \
+ wfunc(&dstPtr2[j], srcpx << (16 - src_depth)); \
+ } \
+ dstPtr2 += dstStride[plane] / 2; \
+ srcPtr2 += srcStride[plane] / 2; \
+ } \
+ } else { \
+ for (i = 0; i < height; i++) { \
+ for (j = 0; j < length; j++) { \
+ int srcpx = rfunc(&srcPtr2[j]); \
+ wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
+ } \
+ dstPtr2 += dstStride[plane] / 2; \
+ srcPtr2 += srcStride[plane] / 2; \
} \
- dstPtr2 += dstStride[plane] / 2; \
- srcPtr2 += srcStride[plane] / 2; \
}
if (isBE(c->dstFormat)) {
if (isBE(c->srcFormat)) {
}
}
} else if (is9_OR_10BPS(c->dstFormat)) {
- const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
+ const int dst_depth = desc_dst->comp[plane].depth;
uint16_t *dstPtr2 = (uint16_t *) dstPtr;
if (is16BPS(c->srcFormat)) {
}
} else /* 8bit */ {
#define COPY8TO9_OR_10(wfunc) \
- for (i = 0; i < height; i++) { \
- for (j = 0; j < length; j++) { \
- const int srcpx = srcPtr[j]; \
- wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
+ if (shiftonly) { \
+ for (i = 0; i < height; i++) { \
+ for (j = 0; j < length; j++) { \
+ const int srcpx = srcPtr[j]; \
+ wfunc(&dstPtr2[j], srcpx << (dst_depth - 8)); \
+ } \
+ dstPtr2 += dstStride[plane] / 2; \
+ srcPtr += srcStride[plane]; \
+ } \
+ } else { \
+ for (i = 0; i < height; i++) { \
+ for (j = 0; j < length; j++) { \
+ const int srcpx = srcPtr[j]; \
+ wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
+ } \
+ dstPtr2 += dstStride[plane] / 2; \
+ srcPtr += srcStride[plane]; \
} \
- dstPtr2 += dstStride[plane] / 2; \
- srcPtr += srcStride[plane]; \
}
if (isBE(c->dstFormat)) {
COPY8TO9_OR_10(AV_WB16);
} else {
if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
length *= 2;
- else if (!desc_src->comp[0].depth_minus1)
+ else if (desc_src->comp[0].depth == 1)
length >>= 3; // monowhite/black
for (i = 0; i < height; i++) {
memcpy(dstPtr, srcPtr, length);
&& (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
c->swscale = rgbToRgbWrapper;
+ /* RGB to planar RGB */
+ if ((srcFormat == AV_PIX_FMT_GBRP && dstFormat == AV_PIX_FMT_GBRAP) ||
+ (srcFormat == AV_PIX_FMT_GBRAP && dstFormat == AV_PIX_FMT_GBRP))
+ c->swscale = planarRgbToplanarRgbWrapper;
+
#define isByteRGB(f) ( \
f == AV_PIX_FMT_RGB32 || \
f == AV_PIX_FMT_RGB32_1 || \
if (srcFormat == AV_PIX_FMT_GBRP && isPlanar(srcFormat) && isByteRGB(dstFormat))
c->swscale = planarRgbToRgbWrapper;
- if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth_minus1 == 7 &&
+ if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
isPackedRGB(srcFormat) && dstFormat == AV_PIX_FMT_GBRP)
c->swscale = rgbToPlanarRgbWrapper;
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR565) ||
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGRA64) ||
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY16) ||
+ IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YA16) ||
+ IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP16)||
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB444) ||
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB48) ||
IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB555) ||
c->swscale = planarCopyWrapper;
}
- if (ARCH_BFIN)
- ff_get_unscaled_swscale_bfin(c);
if (ARCH_PPC)
ff_get_unscaled_swscale_ppc(c);
}
-static void reset_ptr(const uint8_t *src[], int format)
+static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
{
if (!isALPHA(format))
src[3] = NULL;
g = ((i >> 1) & 3) * 85;
b = ( i & 1) * 255;
} else if (c->srcFormat == AV_PIX_FMT_GRAY8 ||
- c->srcFormat == AV_PIX_FMT_Y400A) {
+ c->srcFormat == AV_PIX_FMT_YA8) {
r = g = b = i;
} else {
assert(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
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);
- c->pal_yuv[i] = y + (u << 8) + (v << 16);
+ c->pal_yuv[i] = y + (u << 8) + (v << 16) + (0xFFU << 24);
switch (c->dstFormat) {
case AV_PIX_FMT_BGR32:
#if !HAVE_BIGENDIAN
case AV_PIX_FMT_RGB24:
#endif
- c->pal_rgb[i] = r + (g << 8) + (b << 16);
+ c->pal_rgb[i] = r + (g << 8) + (b << 16) + (0xFFU << 24);
break;
case AV_PIX_FMT_BGR32_1:
#if HAVE_BIGENDIAN
case AV_PIX_FMT_BGR24:
#endif
- c->pal_rgb[i] = (r << 8) + (g << 16) + ((unsigned)b << 24);
+ c->pal_rgb[i] = 0xFF + (r << 8) + (g << 16) + ((unsigned)b << 24);
break;
case AV_PIX_FMT_RGB32_1:
#if HAVE_BIGENDIAN
case AV_PIX_FMT_RGB24:
#endif
- c->pal_rgb[i] = (b << 8) + (g << 16) + ((unsigned)r << 24);
+ c->pal_rgb[i] = 0xFF + (b << 8) + (g << 16) + ((unsigned)r << 24);
break;
case AV_PIX_FMT_RGB32:
#if !HAVE_BIGENDIAN
case AV_PIX_FMT_BGR24:
#endif
default:
- c->pal_rgb[i] = b + (g << 8) + (r << 16);
+ c->pal_rgb[i] = b + (g << 8) + (r << 16) + (0xFFU << 24);
}
}
}
projects / ffmpeg / blobdiff