FCL/sf/os/graphics: comparison graphicscomposition/openwfcompositionengine/common/src/owfimage.c

equal deleted inserted replaced

-:352185384b8a
+:a4b63488e0b0
 OWF_ASSERT(image);
 OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);
 OWF_ASSERT(image->width >= 3 && image->height >= 3);
-copyStride = image->width * image->pixelSize;
+copyStride = OWF_Image_GetStride(image->width, &image->format, 0);
 /* top side replication */
 srcPtr = (OWFuint8*) image->data;
 srcPtr += 1 * image->stride + 0 * image->pixelSize;
 dstPtr = (OWFuint8*) image->data;
 {
 OWFint      countY, widthDiff, heightDiff;
 void*       srcLinePtr;
 OWFpixel*   dstLinePtr;
 OWFboolean  replicateEdges = OWF_FALSE;
+#ifndef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+OWFint      widthBytes;
+#endif
 OWF_ASSERT(dst != 0 && dst->data != NULL);
 OWF_ASSERT(src != 0 && src->data != NULL);
 OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);
+OWF_ASSERT(dst->stride == OWF_Image_GetStride(dst->width, &dst->format, 0));
 srcLinePtr = src->data;
 dstLinePtr = (OWFpixel*) dst->data;
 /* dst image must either be the same size as the src image or 2 pixels
 if (dst->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)
 {
 return OWF_FALSE;
 }
+#ifndef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+widthBytes = OWF_Image_GetStride(src->width, &src->format, 0);
+#endif
 for (countY = src->height; countY; countY--)
 {
 OWFint count = src->width;
 OWFpixel* dstPtr = dstLinePtr;
 switch (src->format.pixelFormat)
 {
 case OWF_IMAGE_ARGB8888:
 {
-#ifdef USE_FLOAT_PIXEL
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;
 while (count > 0)
 {
 dstPtr->color.alpha = (OWFsubpixel)
 dstPtr ++;
 srcPtr ++;
 count--;
 }
 #else
-memcpy(dstLinePtr, srcLinePtr, src->stride);
+memcpy(dstLinePtr, srcLinePtr, widthBytes);
 #endif
 break;
 }
 case OWF_IMAGE_XRGB8888:
 {
 OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;
 while (count > 0)
 {
-#ifdef USE_FLOAT_PIXEL
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 dstPtr->color.alpha = OWF_FULLY_OPAQUE;
 dstPtr->color.red   = (OWFsubpixel)
 OWF_RED_MAX_VALUE * ((*srcPtr & ARGB8888_RED_MASK) >> ARGB8888_RED_SHIFT) / OWF_BYTE_MAX_VALUE;
 dstPtr->color.green = (OWFsubpixel)
 OWF_GREEN_MAX_VALUE * ((*srcPtr & ARGB8888_GREEN_MASK) >> ARGB8888_GREEN_SHIFT) / OWF_BYTE_MAX_VALUE;
 srcPtr ++;
 count--;
 }
 break;
 }
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 case OWF_IMAGE_UYVY:
 {
 OWFuint8* srcPtr = (OWFuint8*) srcLinePtr;
 OWFint y,u,v,r,g,b,x;
 for (x = 0; x < count; x++)
 dstPtr++;
 srcPtr += 4;
 }
 break;
 }
+#endif
 default:
 {
 return OWF_FALSE; /* source format not supported */
 }
 }
 {
 OWFint                  countY;
 OWFuint32*              dstPtr;
 OWFpixel*               srcPtr;
 OWFuint8*               destination;
+#ifndef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+OWFint                  widthBytes;
+#endif
 OWF_ASSERT(dst != 0 && dst->data != NULL);
 OWF_ASSERT(src != 0 && src->data != NULL);
 OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);
+/* Note: src->stride cannot be relied upon to be correct. Assume lines are contiguous. */
 if (src->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)
 {
 return OWF_FALSE;
 }
 {
 OWF_Image_UnpremultiplyAlpha(src);
 }
 destination = (OWFuint8*) dst->data;
+#ifndef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+widthBytes = OWF_Image_GetStride(src->width, &src->format, 0);
+#endif
 for (countY = 0; countY < src->height; countY++)
 {
 dstPtr = (OWFuint32*) destination;
 destination += dst->stride;
 switch (dst->format.pixelFormat)
 {
 case OWF_IMAGE_ARGB8888:
 {
-#ifdef USE_FLOAT_PIXEL
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 OWFint countX;
 OWFuint32 dstPixel = 0;
 for (countX = 0; countX < src->width; countX++)
 {
 *dstPtr = dstPixel;
 dstPtr ++;
 srcPtr ++;
 }
 #else
-memcpy(dstPtr, srcPtr, src->stride);
+memcpy(dstPtr, srcPtr, widthBytes);
-srcPtr = (OWFpixel*)((OWFuint8*)srcPtr + src->stride);
+srcPtr = (OWFpixel*)((OWFuint8*)srcPtr + widthBytes);
 #endif
 break;
 }
 case OWF_IMAGE_XRGB8888:
 {
-#ifdef USE_FLOAT_PIXEL
 OWFint countX;
 OWFuint32 dstPixel = 0;
 for (countX = 0; countX < src->width; countX++)
 {
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 dstPixel  = ARGB8888_ALPHA_MASK;
 dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.red / OWF_RED_MAX_VALUE))   <<
 ARGB8888_RED_SHIFT);
 dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.green / OWF_GREEN_MAX_VALUE)) <<
 ARGB8888_GREEN_SHIFT);
 dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.blue / OWF_BLUE_MAX_VALUE))  <<
 ARGB8888_BLUE_SHIFT);
+#else
+dstPixel = *(OWFuint32*)srcPtr | ARGB8888_ALPHA_MASK;
+#endif
 *dstPtr = dstPixel;
 dstPtr ++;
 srcPtr ++;
 }
-#else
-memcpy(dstPtr, srcPtr, src->stride);
-srcPtr = (OWFpixel*)((OWFuint8*)srcPtr + src->stride);
-#endif
 break;
 }
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+			/* TODO: Fix this code! It should be converting from ARGB into YUV, not the other way around. */
 case OWF_IMAGE_UYVY:
 {
 OWFuint8* srcPtr = (OWFuint8*) srcLinePtr;
 OWFint y,u,v,r,g,b,x;
 for (x = 0; x < count; x++)
 dstPtr++;
 srcPtr += 4;
 }
 break;
 }
+#endif
 default:
 {
 return OWF_FALSE; /* destination format not supported */
 }
 OWFpixel*                pixels;
 OWF_ASSERT(image != 0);
 OWF_ASSERT(image->data != 0);
 OWF_ASSERT(image->format.pixelFormat == OWF_IMAGE_ARGB_INTERNAL);
+/* Note: image->stride cannot be relied upon to be correct. Assume lines are contiguous. */
 numPixels = image->width * image->height;
 pixels = (OWFpixel*) image->data;
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
 for (i = 0; i < numPixels; i++)
 {
 pixels[i].color.red   = (OWFsubpixel) red;
 pixels[i].color.green = (OWFsubpixel) green;
 pixels[i].color.blue  = (OWFsubpixel) blue;
 pixels[i].color.alpha = (OWFsubpixel) alpha;
 }
+#else
+if (alpha == red && alpha == green && alpha == blue)
+{
+/* If all four bytes are the same, just use memset */
+OWFuint32 clearBytes = numPixels * sizeof(OWFuint32);
+memset(pixels, alpha, clearBytes);
+}
+else
+{
+/* Otherwise assign each pixel the packed value */
+OWFuint32* pixelPtr = (OWFuint32*)pixels;
+OWFuint32 pixel;
+pixel = (alpha << ARGB8888_ALPHA_SHIFT) | (red << ARGB8888_RED_SHIFT) |
+(green << ARGB8888_GREEN_SHIFT) | (blue << ARGB8888_BLUE_SHIFT);
+for (i = 0; i < numPixels; i++)
+{
+pixelPtr[i] = pixel;
+}
+}
+#endif
 }
 /*----------------------------------------------------------------------------*/
 OWF_API_CALL void
 OWF_Image_PremultiplyAlpha(OWF_IMAGE* image)
 /*----------------------------------------------------------------------------*/
 #define BLENDER_INNER_LOOP_BEGIN \
 OWFint rowCount = drect.height; \
 while (rowCount > 0) { \
 OWFint colCount = drect.width; \
-while (colCount > 0) { \
+while (colCount > 0) {
-if (!(blend->tsColor && COLOR_MATCH(SC, TSC))) \
-{ \
 #define BLENDER_INNER_LOOP_END \
-DA = blend->destinationFullyOpaque ? OWF_FULLY_OPAQUE : DA; \
-} /* end tsColor check */ \
-srcPtr ++; \
-dstPtr ++; \
---colCount; \
-} \
-srcPtr += srcLineDelta; \
-dstPtr += dstLineDelta; \
---rowCount; \
-}
-#define BLENDER_INNER_LOOP_END_WITH_MASK \
-DA = blend->destinationFullyOpaque ? OWF_FULLY_OPAQUE : DA; \
-} /* end tsColor check */ \
 srcPtr ++; \
 dstPtr ++; \
 maskPtr++; \
 --colCount; \
 } \
 srcPtr += srcLineDelta; \
 dstPtr += dstLineDelta; \
 maskPtr += maskLineDelta; \
 --rowCount; \
 }
-#define TSC blend->tsColor->color
+#define BLENDER_INNER_LOOP_END_NO_MASK \
-#define SC srcPtr->color
+srcPtr ++; \
+dstPtr ++; \
-/* Note: actually would be better to compare integer values
+--colCount; \
-* for TSC match -> eliminate float arithmetic pitfalls
+} \
-*/
+srcPtr += srcLineDelta; \
-#define COLOR_MATCH(x, y) (x.red==y.red && x.green==y.green && x.blue==y.blue)
+dstPtr += dstLineDelta; \
+--rowCount; \
+}
 #define SA srcPtr->color.alpha
 #define SR srcPtr->color.red
 #define SG srcPtr->color.green
 #define SB srcPtr->color.blue
 maskLineDelta = 0;
 }
 srcLineDelta = src->width - srect.width;
 dstLineDelta = dst->width - drect.width;
-if ((transparency & OWF_TRANSPARENCY_GLOBAL_ALPHA) && (GA > (OWF_ALPHA_MAX_VALUE - OWF_ALPHA_MIN_STEP_VALUE)))
-{
-/* Fully opaque, so ignore global alpha */
-transparency &= ~OWF_TRANSPARENCY_GLOBAL_ALPHA;
-}
 /* inner loops */
 switch (transparency)
 {
 case OWF_TRANSPARENCY_NONE:
 {
 BLENDER_INNER_LOOP_BEGIN;
 DR = SR;
 DG = SG;
 DB = SB;
 DA = OWF_FULLY_OPAQUE;
-BLENDER_INNER_LOOP_END;
+BLENDER_INNER_LOOP_END_NO_MASK;
 #else
 memcpy(dstPtr, srcPtr, drect.height*drect.width*4);
 #endif
 break;
 }
 OWF_ALPHA_MAX_VALUE;
 DB = (SB * GA + DB * (OWF_FULLY_OPAQUE - GA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
 DA = GA + (DA * (OWF_FULLY_OPAQUE - GA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
-BLENDER_INNER_LOOP_END;
+BLENDER_INNER_LOOP_END_NO_MASK;
 break;
 }
 case OWF_TRANSPARENCY_SOURCE_ALPHA:
 {
+#ifndef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+OWFuint32 redBlueMask = (ARGB8888_RED_MASK | ARGB8888_BLUE_MASK);
+OWFuint32 alphaGreenMask = (ARGB8888_ALPHA_MASK | ARGB8888_GREEN_MASK);
+OWFuint32 halfRedBlue = 0x00800080;
+#endif
 /*
 rgb     = src.rgb + dst.rgb * (1 - src.alpha)
 alpha    = src.alpha + dst.alpha * (1 - src.alpha)
 */
 BLENDER_INNER_LOOP_BEGIN;
-if (SA > (OWF_ALPHA_MAX_VALUE - OWF_ALPHA_MIN_STEP_VALUE))
+#ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT
+DR = SR + (DR * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) / OWF_ALPHA_MAX_VALUE;
+DG = SG + (DG * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) / OWF_ALPHA_MAX_VALUE;
+DB = SB + (DB * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) / OWF_ALPHA_MAX_VALUE;
+DA = SA + (DA * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) / OWF_ALPHA_MAX_VALUE;
+#else
+{
+OWFuint32 srcP = *(OWFuint32*)srcPtr;
+OWFuint8 srcA = srcP >> ARGB8888_ALPHA_SHIFT;
+if (srcA == OWF_ALPHA_MAX_VALUE)
 {
 /* Fully opaque source pixel */
-DR = SR;
+*(OWFuint32*)dstPtr = srcP;
-DG = SG;
-DB = SB;
-DA = OWF_FULLY_OPAQUE;
 }
 else
 {
-if (SA >= OWF_ALPHA_MIN_STEP_VALUE)
+if (srcA)
 {
-/* Not fully transparent source pixel */
+/* Not fully transparent source pixel. Algorithm after Jim Blinn */
-/*
+OWFuint32 mask = 0xFF - srcA;
-* DR = SR + (DR * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) / OWF_ALPHA_MAX_VALUE;
+OWFuint32 dstP = *(OWFuint32*)dstPtr;
-*/
+OWFuint32 blend;
-DR = SR + (DR * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) >> 8;
-DG = SG + (DG * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) >> 8;
+blend = mask * (dstP & redBlueMask) + halfRedBlue;
-DB = SB + (DB * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) >> 8;
+srcP += ((blend + ((blend >> 8) & redBlueMask) >> 8)) & redBlueMask;
-DA = SA + (DA * (OWF_FULLY_OPAQUE - SA) + OWF_BLEND_ROUNDING_VALUE) >> 8;
+blend = mask * ((dstP >> 8) & redBlueMask) + halfRedBlue;
+srcP += (blend + ((blend >> 8) & redBlueMask)) & alphaGreenMask;
+*(OWFuint32*)dstPtr = srcP;
 }
 }
-BLENDER_INNER_LOOP_END;
+}
+#endif
+BLENDER_INNER_LOOP_END_NO_MASK;
 break;
 }
 case OWF_TRANSPARENCY_MASK:
 {
 OWF_ALPHA_MAX_VALUE;
 DB = (SB * MA + DB * (OWF_FULLY_OPAQUE - MA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
 DA = MA + (DA * (OWF_FULLY_OPAQUE - MA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
-BLENDER_INNER_LOOP_END_WITH_MASK;
+BLENDER_INNER_LOOP_END;
 break;
 }
 case OWF_TRANSPARENCY_GLOBAL_ALPHA | OWF_TRANSPARENCY_SOURCE_ALPHA:
 {
 OWF_ALPHA_MAX_VALUE;
 DB = (SB * GA + DB * (OWF_FULLY_OPAQUE - SAEA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
 DA = SAEA + (DA * (OWF_FULLY_OPAQUE - SAEA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
-BLENDER_INNER_LOOP_END;
+BLENDER_INNER_LOOP_END_NO_MASK;
 break;
 }
 case OWF_TRANSPARENCY_GLOBAL_ALPHA | OWF_TRANSPARENCY_MASK:
 {
 OWF_ALPHA_MAX_VALUE;
 DA = MAEA + (DA * (OWF_FULLY_OPAQUE - MAEA) + OWF_BLEND_ROUNDING_VALUE) /
 OWF_ALPHA_MAX_VALUE;
 //No need to check with OWF_ALPHA_MIN_VALUE as it is zero
 OWF_ASSERT(GA <= OWF_ALPHA_MAX_VALUE);
-BLENDER_INNER_LOOP_END_WITH_MASK;
+BLENDER_INNER_LOOP_END;
 break;
 }
 default:
 {
 return 3;
 }
 case OWF_IMAGE_RGB565:
 case OWF_IMAGE_L16:
+case OWF_IMAGE_UYVY:
 {
 return 2;
 }
 case OWF_IMAGE_L8:
-case OWF_IMAGE_UYVY:
 {
 return 1;
 }
 case OWF_IMAGE_L1:
 }
 case OWF_IMAGE_ARGB8888:
 case OWF_IMAGE_XRGB8888:
 case OWF_IMAGE_L32:
+case OWF_IMAGE_UYVY:
 {
 padding = 4;
 break;
 }
 padding = 2;
 break;
 }
 case OWF_IMAGE_L8:
-case OWF_IMAGE_UYVY:
 {
 padding = 1;
 break;
 }

branch	NewGraphicsArchitecture
changeset 39	a4b63488e0b0
parent 35	3aa07f06a4b7
child 61	4ac0d9f65e95