1 /* Copyright (c) 2009 The Khronos Group Inc.

     2  *

     3  * Permission is hereby granted, free of charge, to any person obtaining a

     4  * copy of this software and/or associated documentation files (the

     5  * "Materials"), to deal in the Materials without restriction, including

     6  * without limitation the rights to use, copy, modify, merge, publish,

     7  * distribute, sublicense, and/or sell copies of the Materials, and to

     8  * permit persons to whom the Materials are furnished to do so, subject to

     9  * the following conditions:

    10  *

    11  * The above copyright notice and this permission notice shall be included

    12  * in all copies or substantial portions of the Materials.

    13  *

    14  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

    18  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

    19  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

    20  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21  */

    22 

    23 #ifdef __cplusplus

    24 extern "C"

    25 {

    26 #endif

    27 

    28 #include <string.h>

    29 #include <stdlib.h>

    30 #include <stdio.h>

    31 #include <math.h>

    32 

    33 #include "owfobject.h"

    34 #include "owfimage.h"

    35 #include "owfutils.h"

    36 #include "owfmemory.h"

    37 #include "owfdebug.h"

    38 #include "owfdisplaycontextgeneral.h"

    39 

    40 #ifdef OWF_IMAGE_INTERNAL_PIXEL_IS_FLOAT

    41 #define roundSubPixel(p) ((OWFuint32)((p) + 0.5f))

    42 #else

    43 #define roundSubPixel(p) (p)

    44 #endif

    45 

    46 

    47 /*----------------------------------------------------------------------------*/

    48 OWF_API_CALL void

    49 OWF_IMAGE_Ctor(void* self)

    50 {

    51     self = self;

    52 }

    53 

    54 /*----------------------------------------------------------------------------*/

    55 OWF_API_CALL void

    56 OWF_IMAGE_Dtor(void* self)

    57 {

    58     OWF_IMAGE* image;

    59 

    60     image = (OWF_IMAGE*)self;

    61 

    62     if (image && image->data)

    63     {

    64         if (!image->foreign)

    65         {

    66             OWF_Image_FreeData(0, &image->data);

    67         }

    68     }

    69 

    70     if (image)

    71     {

    72         memset(image, 0, sizeof(OWF_IMAGE));

    73     }

    74 }

    75 

    76 /*----------------------------------------------------------------------------*/

    77 static OWFfloat

    78 NonLinear(OWFfloat x)

    79 {

    80     if (x <= 0.00304f)

    81     {

    82         return 12.92f * x;

    83     }

    84     return 1.0556f * pow(x, 1.f/2.4f) - 0.0556f;

    85 }

    86 

    87 /*----------------------------------------------------------------------------*/

    88 static OWFfloat

    89 Linear(OWFfloat x)

    90 {

    91     if (x <= 0.03928)

    92     {

    93         return x / 12.92f;

    94     }

    95     return pow((x + 0.0556f) / 1.0556f, 2.4f);

    96 }

    97 

    98 /*----------------------------------------------------------------------------*/

    99 OWF_API_CALL void

   100 OWF_Image_NonLinearizeData(OWF_IMAGE* image)\

   101 {

   102     OWFpixel*            ptr;

   103     OWFint               count;

   104 

   105     OWF_ASSERT(image != NULL && image->data != NULL);

   106     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   107 

   108     if (!image->format.linear)

   109     {

   110         return;

   111     }

   112 

   113     ptr = (OWFpixel*) image->data;

   114     count = image->width * image->height;

   115 

   116     while (count > 0)

   117     {

   118         ptr->color.red   = (OWFsubpixel) NonLinear(ptr->color.red /

   119                                OWF_RED_MAX_VALUE) * OWF_RED_MAX_VALUE;

   120         ptr->color.green = (OWFsubpixel) NonLinear(ptr->color.green /

   121                                OWF_GREEN_MAX_VALUE) * OWF_GREEN_MAX_VALUE;

   122         ptr->color.blue  = (OWFsubpixel) NonLinear(ptr->color.blue /

   123                                OWF_BLUE_MAX_VALUE) * OWF_BLUE_MAX_VALUE;

   124 

   125         --count;

   126         ptr++;

   127     }

   128 

   129     image->format.linear = OWF_FALSE;

   130 }

   131 

   132 /*----------------------------------------------------------------------------*/

   133 OWF_API_CALL void

   134 OWF_Image_LinearizeData(OWF_IMAGE* image)

   135 {

   136     OWFpixel*               ptr;

   137     OWFuint                 count;

   138 

   139     OWF_ASSERT(image != NULL && image->data != NULL);

   140     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   141 

   142     if (image->format.linear)

   143     {

   144         return;

   145     }

   146 

   147     ptr = (OWFpixel*) image->data;

   148     count = image->width * image->height;

   149 

   150     while (count > 0)

   151     {

   152         ptr->color.red   = (OWFsubpixel) Linear(ptr->color.red /

   153                                OWF_RED_MAX_VALUE) * OWF_RED_MAX_VALUE;

   154         ptr->color.green = (OWFsubpixel) Linear(ptr->color.green /

   155                                OWF_GREEN_MAX_VALUE) * OWF_GREEN_MAX_VALUE;

   156         ptr->color.blue  = (OWFsubpixel) Linear(ptr->color.blue /

   157                                OWF_BLUE_MAX_VALUE) * OWF_BLUE_MAX_VALUE;

   158 

   159         --count;

   160         ptr += image->pixelSize;

   161     }

   162 

   163     image->format.linear = OWF_TRUE;

   164 

   165 }

   166 

   167 /*----------------------------------------------------------------------------*/

   168 #define GAMMA(color, max, gamma) (max * pow(color/max, gamma))

   169 

   170 OWF_API_CALL void

   171 OWF_Image_Gamma(OWF_IMAGE* image, OWFfloat gamma)

   172 {

   173     OWFpixel*            ptr;

   174     OWFint               count;

   175 

   176     OWF_ASSERT(image != NULL && image->data != NULL);

   177     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   178 

   179     if (gamma == 1.0f)

   180     {

   181         return;

   182     }

   183 

   184     ptr = (OWFpixel*) image->data;

   185     count = image->width * image->height;

   186 

   187     while (count > 0)

   188     {

   189         ptr->color.red   =

   190             (OWFsubpixel) GAMMA(ptr->color.red, OWF_RED_MAX_VALUE, gamma);

   191         ptr->color.green =

   192             (OWFsubpixel) GAMMA(ptr->color.green, OWF_GREEN_MAX_VALUE, gamma);

   193         ptr->color.blue  =

   194             (OWFsubpixel) GAMMA(ptr->color.blue, OWF_BLUE_MAX_VALUE, gamma);

   195 

   196         --count;

   197         ptr++;

   198     }

   199 }

   200 

   201 /*----------------------------------------------------------------------------*/

   202 OWF_API_CALL void

   203 OWF_Image_EdgeReplication(OWF_IMAGE* image)

   204 {

   205     OWFint          y;

   206     OWFint          copyStride;

   207     OWFuint8*       srcPtr      = NULL;

   208     OWFuint8*       dstPtr      = NULL;

   209     

   210     OWF_ASSERT(image);

   211     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   212     OWF_ASSERT(image->width >= 3 && image->height >= 3);

   213     

   214     copyStride = image->width * image->pixelSize;    

   215     

   216     /* top side replication */

   217     srcPtr = (OWFuint8*) image->data;

   218     srcPtr += 1 * image->stride + 0 * image->pixelSize;

   219     dstPtr = (OWFuint8*) image->data;

   220 

   221     memcpy(dstPtr, srcPtr, copyStride);

   222     

   223     /* bottom side replication */

   224     srcPtr = (OWFuint8*) image->data;

   225     srcPtr += (image->height-2) * image->stride + 0 * image->pixelSize;        

   226     dstPtr = (OWFuint8*) image->data;

   227     dstPtr += (image->height-1) * image->stride + 0 * image->pixelSize;

   228     

   229     memcpy(dstPtr, srcPtr, copyStride);

   230     

   231     /* left side replication */

   232     for (y = 0; y < image->height; y++)

   233     {

   234         OWF_Image_SetPixel(image, 0, y, OWF_Image_GetPixelPtr(image, 1, y));

   235     }

   236     

   237     /* right side replication */

   238     for (y = 0; y < image->height; y++)

   239     {

   240         OWF_Image_SetPixel(image, image->width-1, y, OWF_Image_GetPixelPtr(image,

   241                                                               image->width-2,

   242                                                               y));

   243     }   

   244     

   245 }

   246 

   247 /*----------------------------------------------------------------------------*/

   248 OWF_API_CALL OWFboolean

   249 OWF_Image_SourceFormatConversion(OWF_IMAGE* dst, OWF_IMAGE* src)

   250 {

   251     OWFint      countY, widthDiff, heightDiff;

   252     void*       srcLinePtr;

   253     OWFpixel*   dstLinePtr;

   254     OWFboolean  replicateEdges = OWF_FALSE;

   255     

   256 

   257     OWF_ASSERT(dst != 0 && dst->data != NULL);

   258     OWF_ASSERT(src != 0 && src->data != NULL);

   259     OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   260     

   261     srcLinePtr = src->data;

   262     dstLinePtr = (OWFpixel*) dst->data;    

   263     

   264     /* dst image must either be the same size as the src image or 2 pixels 

   265        bigger (enough space to perform edge replication) */

   266     if (dst->width != src->width || dst->height != src->height)

   267     {

   268         widthDiff = dst->width - src->width;

   269         heightDiff = dst->height - src->height;

   270         

   271         if (widthDiff == 2 && heightDiff == 2)

   272         {

   273             replicateEdges = OWF_TRUE;   

   274             /* start of the destination buffer should have a 1 pixel offset */

   275             dstLinePtr = (OWFpixel*) dst->data + 1 * dst->width + 1;

   276         }

   277         else

   278         {

   279             return OWF_FALSE;

   280         }

   281     }

   282 

   283     if (dst->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)

   284     {

   285         return OWF_FALSE;

   286     }

   287 

   288     for (countY = src->height; countY; countY--)

   289     {

   290         OWFint count = src->width;

   291         OWFpixel* dstPtr = dstLinePtr;

   292     

   293         switch (src->format.pixelFormat)

   294         {

   295             case OWF_IMAGE_ARGB8888:

   296             {

   297                 OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;

   298     

   299                 while (count > 0)

   300                 {

   301                     dstPtr->color.alpha = (OWFsubpixel)

   302                         OWF_ALPHA_MAX_VALUE * ((*srcPtr & ARGB8888_ALPHA_MASK) >> ARGB8888_ALPHA_SHIFT) / OWF_BYTE_MAX_VALUE;

   303                     dstPtr->color.red   = (OWFsubpixel)

   304                         OWF_RED_MAX_VALUE * ((*srcPtr & ARGB8888_RED_MASK) >> ARGB8888_RED_SHIFT) / OWF_BYTE_MAX_VALUE;

   305                     dstPtr->color.green = (OWFsubpixel)

   306                         OWF_GREEN_MAX_VALUE * ((*srcPtr & ARGB8888_GREEN_MASK)>> ARGB8888_GREEN_SHIFT) / OWF_BYTE_MAX_VALUE;

   307                     dstPtr->color.blue  = (OWFsubpixel)

   308                         OWF_BLUE_MAX_VALUE * ((*srcPtr & ARGB8888_BLUE_MASK) >> ARGB8888_BLUE_SHIFT) / OWF_BYTE_MAX_VALUE;

   309                     dstPtr ++;

   310                     srcPtr ++;

   311                     count--;

   312                 }

   313                 break;

   314             }

   315     

   316             case OWF_IMAGE_XRGB8888:

   317             {

   318                 OWFuint32* srcPtr = (OWFuint32*) srcLinePtr;

   319                 

   320                 while (count > 0)

   321                 {

   322                     dstPtr->color.alpha = OWF_FULLY_OPAQUE;

   323                     dstPtr->color.red   = (OWFsubpixel)

   324                         OWF_RED_MAX_VALUE * ((*srcPtr & ARGB8888_RED_MASK) >> ARGB8888_RED_SHIFT) / OWF_BYTE_MAX_VALUE;

   325                     dstPtr->color.green = (OWFsubpixel)

   326                         OWF_GREEN_MAX_VALUE * ((*srcPtr & ARGB8888_GREEN_MASK) >> ARGB8888_GREEN_SHIFT) / OWF_BYTE_MAX_VALUE;

   327                     dstPtr->color.blue  = (OWFsubpixel)

   328                         OWF_BLUE_MAX_VALUE * ((*srcPtr & ARGB8888_BLUE_MASK) >> ARGB8888_BLUE_SHIFT) / OWF_BYTE_MAX_VALUE;

   329                     dstPtr ++;

   330                     srcPtr ++;

   331                     count--;

   332                 }

   333                 break;

   334             }

   335     

   336             case OWF_IMAGE_RGB565:

   337             {

   338                 OWFfloat tmp;

   339                 OWFuint16* srcPtr = (OWFuint16*) srcLinePtr;

   340                 

   341                 while (count > 0)

   342                 {

   343                     /*

   344                      * Formula for converting channel value is:

   345                      * Each channel is multiplied by (2^d - 1)/(2^s -1)

   346                      * where d is dest channel bits and s is source channel bits.

   347                      */

   348                     dstPtr->color.alpha = (OWFsubpixel) OWF_FULLY_OPAQUE;

   349     

   350                     tmp = (OWFfloat)((*srcPtr & RGB565_RED_MASK) >> RGB565_RED_SHIFT);

   351                     dstPtr->color.red   = (OWFsubpixel)OWF_RED_MAX_VALUE * tmp / 31.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

   352     

   353                     tmp = (OWFfloat)((*srcPtr & RGB565_GREEN_MASK) >> RGB565_GREEN_SHIFT);

   354                     dstPtr->color.green = (OWFsubpixel)OWF_GREEN_MAX_VALUE * tmp / 63.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

   355     

   356                     tmp = (OWFfloat)(*srcPtr & RGB565_BLUE_MASK);

   357                     dstPtr->color.blue  = (OWFsubpixel)OWF_BLUE_MAX_VALUE * tmp / 31.0f + OWF_SOURCE_CONVERSION_ROUNDING_VALUE;

   358     

   359                     dstPtr ++;

   360                     srcPtr ++;

   361                     count--;

   362                 }

   363                 break;

   364             }

   365     

   366             default:

   367             {

   368                 return OWF_FALSE; /* source format not supported */

   369             }

   370         }

   371         

   372         dstLinePtr+=dst->width;

   373         srcLinePtr=(OWFuint8*)srcLinePtr+src->stride;

   374     }

   375     

   376     if (replicateEdges)

   377     {

   378         OWF_Image_EdgeReplication(dst);

   379     }

   380 

   381     return OWF_TRUE;

   382 }

   383 

   384 /*----------------------------------------------------------------------------*/

   385 OWF_PUBLIC OWFint

   386 OWF_Image_GetStride(OWFint width, const OWF_IMAGE_FORMAT* format, OWFint minimumStride)

   387 {

   388     OWFint                  size;

   389     OWFint                  pixelSize;

   390 

   391     OWF_ASSERT(format);

   392 

   393     pixelSize = OWF_Image_GetFormatPixelSize(format->pixelFormat);

   394 

   395     if (pixelSize < 0)

   396     {

   397         /* negative pixelSize means that pixel size is a fraction

   398          * (1/-pixelSize) of a byte, e.g. -8 means pixel has size

   399          * of one bit. */

   400 

   401         size = (width + 1) / -pixelSize;

   402     }

   403     else

   404     {

   405         size = width * pixelSize;

   406     }

   407     if (size<minimumStride)

   408     {

   409         size=minimumStride;

   410     }

   411     if (format->rowPadding)

   412     {

   413         size += format->rowPadding - 1;

   414         size -= size % format->rowPadding;

   415     }

   416     return size;

   417 }

   418 

   419 /*----------------------------------------------------------------------------*/

   420 OWF_API_CALL OWFboolean

   421 OWF_Image_IsValidDestinationFormat(OWF_IMAGE_FORMAT* format)

   422 {

   423     switch (format->pixelFormat)

   424     {

   425         case OWF_IMAGE_ARGB8888:

   426         {

   427             return OWF_TRUE;

   428         }

   429         case OWF_IMAGE_XRGB8888:

   430         {

   431             return OWF_TRUE;

   432         }

   433 #ifdef SUPPORT_565_OUTPUT

   434         case OWF_IMAGE_RGB565:

   435         {

   436             return OWF_TRUE;

   437         }

   438 #endif

   439         default:

   440         {

   441             return OWF_FALSE; /* destination format not supported */

   442         }

   443     }

   444 }

   445 

   446 /*----------------------------------------------------------------------------*/

   447 OWF_API_CALL OWFboolean

   448 OWF_Image_DestinationFormatConversion(OWF_IMAGE* dst, OWF_IMAGE* src)

   449 {

   450     OWFint                  countY;

   451     OWFuint32*              dstPtr;

   452     OWFpixel*               srcPtr;

   453 

   454     OWF_ASSERT(dst != 0 && dst->data != NULL);

   455     OWF_ASSERT(src != 0 && src->data != NULL);

   456     OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   457 

   458     if (src->format.pixelFormat != OWF_IMAGE_ARGB_INTERNAL)

   459     {

   460         return OWF_FALSE;

   461     }

   462 

   463     /* src and data must have equal amount of pixels */

   464     if (dst->width != src->width || dst->height != src->height)

   465     {

   466         return OWF_FALSE;

   467     }

   468 

   469     dstPtr = (OWFuint32*) dst->data;

   470     srcPtr = (OWFpixel*) src->data;

   471 

   472     if (dst->format.premultiplied && !src->format.premultiplied)

   473     {

   474         OWF_Image_PremultiplyAlpha(src);

   475     }

   476     else if (!dst->format.premultiplied && src->format.premultiplied)

   477     {

   478         OWF_Image_UnpremultiplyAlpha(src);

   479     }

   480 

   481     for (countY = 0; countY < src->height; countY++)

   482     {   

   483         OWFuint8* destination = (OWFuint8*) dst->data;

   484         destination += countY*dst->stride;

   485         dstPtr = (OWFuint32*) destination;    

   486     

   487         switch (dst->format.pixelFormat)

   488         {

   489             case OWF_IMAGE_ARGB8888:

   490             {

   491                 OWFint countX;

   492                 OWFuint32 dstPixel = 0;               

   493                 

   494                 for (countX = 0; countX < src->width; countX++)

   495                 {

   496                     dstPixel  = ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.alpha / OWF_ALPHA_MAX_VALUE)) <<

   497                                 ARGB8888_ALPHA_SHIFT);

   498                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.red / OWF_RED_MAX_VALUE))   <<

   499                                 ARGB8888_RED_SHIFT);

   500                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.green / OWF_GREEN_MAX_VALUE)) <<

   501                                 ARGB8888_GREEN_SHIFT);

   502                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.blue / OWF_BLUE_MAX_VALUE))  <<

   503                                 ARGB8888_BLUE_SHIFT);

   504                     *dstPtr = dstPixel;

   505                     dstPtr ++;

   506                     srcPtr ++;

   507                 }

   508                 break;

   509             }

   510     

   511             case OWF_IMAGE_XRGB8888:

   512             {

   513                 OWFint countX;

   514                 OWFuint32 dstPixel = 0;

   515                 

   516                 for (countX = 0; countX < src->width; countX++)

   517                 {

   518                     dstPixel  = ARGB8888_ALPHA_MASK;

   519                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.red / OWF_RED_MAX_VALUE))   <<

   520                                 ARGB8888_RED_SHIFT);

   521                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.green / OWF_GREEN_MAX_VALUE)) <<

   522                                 ARGB8888_GREEN_SHIFT);

   523                     dstPixel |= ((OWFuint8)(roundSubPixel(OWF_BYTE_MAX_VALUE * srcPtr->color.blue / OWF_BLUE_MAX_VALUE))  <<

   524                                 ARGB8888_BLUE_SHIFT);

   525                     *dstPtr = dstPixel;

   526                     dstPtr ++;

   527                     srcPtr ++;

   528                 }

   529                 break;

   530             }

   531     

   532             default:

   533             {

   534                 return OWF_FALSE; /* destination format not supported */

   535             }

   536         }

   537     }

   538 

   539     return OWF_TRUE;

   540 }

   541 

   542 /*----------------------------------------------------------------------------*/

   543 OWF_API_CALL void

   544 OWF_Image_Init(OWF_IMAGE* image)

   545 {

   546     OWF_ASSERT(NULL != image);

   547     memset(image, 0, sizeof(OWF_IMAGE));

   548 }

   549 

   550 /*----------------------------------------------------------------------------*/

   551 OWF_PUBLIC OWF_IMAGE*

   552 OWF_Image_Create(OWFint width,

   553                  OWFint height,

   554                  const OWF_IMAGE_FORMAT* format,

   555                  void* buffer,

   556                  OWFint minimumStride

   557                  )

   558 {

   559     OWF_IMAGE*      image;

   560 

   561     image = CREATE(OWF_IMAGE);

   562 

   563     if (image)

   564     {

   565 

   566         image->format.pixelFormat   = format->pixelFormat;

   567         image->format.linear        = format->linear;

   568         image->format.premultiplied = format->premultiplied;

   569         image->format.rowPadding    = format->rowPadding;

   570 

   571         image->pixelSize    = OWF_Image_GetFormatPixelSize(format->pixelFormat);

   572         image->width        = width;

   573         image->height       = height;

   574 

   575         /* stride is row length in bytes (aligned according to image format) */

   576         image->stride = OWF_Image_GetStride(width, &image->format, minimumStride);

   577         image->foreign  = (buffer) ? OWF_TRUE : OWF_FALSE;

   578         image->dataMax = image->stride * height;

   579 

   580         DPRINT(("OWF_Image_Create:"));

   581         DPRINT(("  Pixel format     = %x", format->pixelFormat));

   582         DPRINT(("  Linear           = %d", format->linear));

   583         DPRINT(("  Premultiplied    = %d", format->premultiplied));

   584         DPRINT(("  Row alignment    = %d bytes", format->rowPadding));

   585         DPRINT(("  Pixel size       = %d", image->pixelSize));

   586         DPRINT(("  Width            = %d", image->width));

   587         DPRINT(("  Height           = %d", image->height));

   588         DPRINT(("  Stride           = %d", image->stride));

   589         DPRINT(("  Foreign data     = %d", image->foreign));

   590         DPRINT(("  Data size        = %d", image->dataMax));

   591         if (image->dataMax > 0)

   592         {

   593             image->data = (image->foreign) ? (buffer) :

   594                 OWF_Image_AllocData(0, width, height, format->pixelFormat);

   595         }

   596         else

   597         {

   598             /* either overflow occured or width/height is zero */

   599             if (width && height)

   600             {

   601                 DPRINT(("OWF_Image_Create: Overflow in image size calculation."));

   602             }

   603             else

   604             {

   605                 DPRINT(("OWF_Image_Create: width or height is zero."));

   606             }

   607         }

   608     }

   609 

   610     if (!(image && image->data && (image->dataMax > 0)))

   611     {

   612         DPRINT(("OWF_Image_Create: Image creation failed (image = %p, "

   613                 "data = %p, dataSize = %d)",

   614                 image, image ? (void*)(image->data) : (void*)NULL, image?image->dataMax:-1));

   615         DESTROY(image);

   616         return NULL;

   617     }

   618     return image;

   619 }

   620 

   621 /*----------------------------------------------------------------------------*/

   622 OWF_PUBLIC void OWF_Image_Destroy(OWF_IMAGE* image)

   623 {

   624     if (image)

   625         {

   626         DESTROY(image);

   627         }

   628 }

   629 

   630 

   631 /*----------------------------------------------------------------------------*/

   632 OWF_API_CALL OWF_IMAGE*

   633 OWF_Image_Copy(const OWF_IMAGE* image)

   634 {

   635     OWF_IMAGE* newImage = NULL;

   636 

   637     OWF_ASSERT(image);

   638 

   639     newImage = CREATE(OWF_IMAGE);

   640     if (newImage)

   641     {

   642         memcpy(newImage, image, sizeof(*newImage));

   643         if (!image->foreign)

   644         {

   645             newImage->data = xalloc(1, image->dataMax);

   646             if (newImage->data)

   647             {

   648                 memcpy(newImage->data,

   649                        image->data,

   650                        image->height*image->stride);

   651             }

   652         }

   653     }

   654 

   655     return newImage;

   656 }

   657 

   658 /*----------------------------------------------------------------------------*/

   659 OWF_API_CALL OWFboolean

   660 OWF_Image_SetSize(OWF_IMAGE* image,

   661                   OWFint width,

   662                   OWFint height)

   663 {

   664     OWFint                  size;

   665     OWFint                  stride;

   666 

   667     OWF_ASSERT(image);

   668     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL ||

   669             image->format.pixelFormat==OWF_IMAGE_L32);

   670     

   671     /** note that this setsize ignores any specialised stride **/

   672     stride = OWF_Image_GetStride(width, &image->format, 0);

   673     size = height * stride;

   674 

   675     /* change source size if buffer have enough space */

   676     if (size > 0 && size <= image->dataMax)

   677     {

   678         image->height = height;

   679         image->width  = width;

   680         image->stride = stride;

   681         return OWF_TRUE;

   682     }

   683     return OWF_FALSE;

   684 }

   685 /*----------------------------------------------------------------------------*/

   686 OWF_API_CALL void

   687 OWF_Image_SetFlags(OWF_IMAGE* image,

   688                   OWFboolean premultiply,

   689                   OWFboolean linear)

   690     {

   691     OWF_ASSERT(image);

   692     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL ||

   693             image->format.pixelFormat==OWF_IMAGE_L32);

   694     image->format.linear=linear;

   695     image->format.premultiplied=premultiply;

   696     }

   697 

   698 /*----------------------------------------------------------------------------*/

   699 OWF_API_CALL void

   700 OWF_Image_SetPixelBuffer(OWF_IMAGE* image,      void* buffer)

   701     {

   702     OWF_ASSERT(image);

   703     OWF_ASSERT(buffer);

   704     OWF_ASSERT(image->foreign);

   705     if (image->foreign)

   706         {

   707         image->data=buffer;

   708         }

   709     }

   710 /*----------------------------------------------------------------------------*/

   711 /* NEVER USED

   712 OWF_API_CALL OWFboolean

   713 OWF_Image_SetPixelData(OWF_IMAGE* image,

   714                        OWFint width,

   715                        OWFint height,

   716                        const OWF_IMAGE_FORMAT* format,

   717                        void* buffer)

   718 {

   719     OWFint                  size = 0,

   720                             stride = 0;

   721 

   722     OWF_ASSERT(image && format);

   723 

   724     stride  = OWF_Image_GetStride(width, format);

   725     size    = height * stride;

   726 

   727     if (size <= 0)

   728     {

   729         return OWF_FALSE; 

   730     }

   731 

   732     if (!image->foreign)

   733     {

   734         OWF_Image_FreeData(0, &image->data);

   735     }

   736 

   737     image->format.pixelFormat   = format->pixelFormat;

   738     image->format.linear        = format->linear;

   739     image->format.premultiplied = format->premultiplied;

   740     image->format.rowPadding    = format->rowPadding;

   741 

   742     image->pixelSize    = OWF_Image_GetFormatPixelSize(format->pixelFormat);

   743     image->width        = width;

   744     image->height       = height;

   745     image->stride       = stride;

   746     image->foreign      = OWF_TRUE;

   747     image->dataMax      = size;

   748     image->data         = buffer;

   749 

   750     return OWF_TRUE;

   751 }

   752 */

   753 /*----------------------------------------------------------------------------*/

   754 OWF_API_CALL OWFboolean

   755 OWF_Image_Blit(OWF_IMAGE* dst,

   756                OWF_RECTANGLE const* dstRect,

   757                OWF_IMAGE const* src,

   758                OWF_RECTANGLE const* srcRect)

   759 {

   760     OWF_RECTANGLE           bounds, rect, drect, srect;

   761     OWFint                  lineCount   = 0;

   762     OWFint                  copyStride  = 0;

   763     OWFuint8*               srcPtr      = NULL;

   764     OWFuint8*               dstPtr      = NULL;

   765 

   766     OWF_ASSERT(dst != 0 && dst->data != NULL);

   767     OWF_ASSERT(src != 0 && src->data != NULL);

   768     OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   769     OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   770 

   771     OWF_Rect_Set(&bounds, 0, 0, dst->width, dst->height);

   772     OWF_Rect_Set(&rect,

   773                  dstRect->x, dstRect->y,

   774                  srcRect->width, srcRect->height);

   775     OWF_Rect_Set(&srect,

   776                  srcRect->x, srcRect->y,

   777                  srcRect->width, srcRect->height);

   778 

   779     /* clip destination rectangle against bounds */

   780     if (!OWF_Rect_Clip(&drect, &rect, &bounds))

   781     {

   782         return OWF_FALSE;

   783     }

   784 

   785     if (src->pixelSize != dst->pixelSize)

   786     {

   787         DPRINT(("OWF_Image_Blit(): pixels sizes differ\n"));

   788         return OWF_FALSE;

   789     }

   790 

   791     lineCount = srect.height;

   792     copyStride = srect.width * src->pixelSize;

   793 

   794     /* use bytepointers in copy  - generic */

   795     srcPtr = (OWFuint8*) src->data;

   796     srcPtr += srect.y * src->stride + srect.x * src->pixelSize;

   797     dstPtr = (OWFuint8*)dst->data;

   798     dstPtr += drect.y * dst->stride + drect.x * src->pixelSize;

   799 

   800     while (lineCount > 0)

   801     {

   802         --lineCount;

   803 

   804         memcpy(dstPtr, srcPtr, copyStride);

   805 

   806         srcPtr += src->stride;

   807         dstPtr += dst->stride;

   808     }

   809 

   810     return OWF_TRUE;

   811 }

   812 

   813 /*----------------------------------------------------------------------------*/

   814 OWF_API_CALL OWFpixel*

   815 OWF_Image_GetPixelPtr(OWF_IMAGE* image,

   816                       OWFint x,

   817                       OWFint y)

   818 {

   819     OWF_ASSERT(image && image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   820     if (!(image && image->data))

   821     {

   822         return 0;

   823     }

   824 

   825     x = CLAMP(x, 0, image->width-1);

   826     y = CLAMP(y, 0, image->height-1);

   827 

   828     return (OWFpixel*)image->data + y * image->width  + x ;

   829 }

   830 

   831 /*----------------------------------------------------------------------------*/

   832 OWF_API_CALL void

   833 OWF_Image_GetPixel(OWF_IMAGE* image,

   834                    OWFint x,

   835                    OWFint y,

   836                    OWFpixel* pixel)

   837 {

   838     OWFpixel*               temp = NULL;

   839 

   840     OWF_ASSERT(pixel);

   841 

   842     if (!(image && image->data))

   843     {

   844         return;

   845     }

   846     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   847 

   848     pixel->color.alpha = 0;

   849     pixel->color.red = 0;

   850     pixel->color.green = 0;

   851     pixel->color.blue = 0;

   852 

   853     if (x < 0 || y < 0 || x >= image->width || y >= image->height)

   854     {

   855         return;

   856     }

   857 

   858     temp = (OWFpixel*)image->data + y * image->width  + x;

   859 

   860     pixel->color.alpha = temp->color.alpha;

   861     pixel->color.red = temp->color.red;

   862     pixel->color.green = temp->color.green;

   863     pixel->color.blue = temp->color.blue;

   864 }

   865 

   866 /*----------------------------------------------------------------------------*/

   867 OWF_API_CALL void

   868 OWF_Image_SetPixel(OWF_IMAGE* image,

   869                    OWFint x,

   870                    OWFint y,

   871                    OWFpixel const* pixel)

   872 {

   873     OWFpixel*               data = NULL;

   874 

   875     if (!(image && image->data))

   876     {

   877         return;

   878     }

   879     OWF_ASSERT(image->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   880 

   881     if(x < 0 || y < 0 || x >= image->width || y >= image->height)

   882     {

   883         return;

   884     }

   885 

   886 

   887     data = (OWFpixel*)image->data + y * image->width + x;

   888 

   889     data->color.red = pixel->color.red;

   890     data->color.green = pixel->color.green;

   891     data->color.blue = pixel->color.blue;

   892     data->color.alpha = pixel->color.alpha;

   893 }

   894 

   895 /*----------------------------------------------------------------------------*/

   896 OWF_API_CALL OWFboolean

   897 OWF_Image_PointSamplingStretchBlit(OWF_IMAGE* dst,

   898                                    OWF_RECTANGLE* dstRect,

   899                                    OWF_IMAGE* src,

   900                                    OWFfloat* srcRect)

   901 {

   902     OWFint                  ox = 0, oy = 0;

   903     OWFfloat                dx = 0.f, dy = 0.f; 

   904     OWFint                  x, y;

   905 

   906     /* images must be valid */

   907     if (!((src != NULL) && (src->data != NULL) &&

   908           (dst != NULL) && (dst->data != NULL)))

   909     {

   910         return OWF_FALSE;

   911     }

   912     OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   913     OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   914 

   915     /* ditto with rectangles, too */

   916     if (!((dstRect != NULL) && (dstRect->width && dstRect->height) &&

   917           (srcRect != NULL) && (srcRect[2] && srcRect[3])))

   918     {

   919         return OWF_FALSE;

   920     }

   921 

   922     /* Note: bounds check missing */

   923 

   924     if (src->pixelSize != dst->pixelSize)

   925     {

   926         return OWF_FALSE;

   927     }

   928 

   929     /* solve scaling ratios for image */

   930     dx = (OWFfloat) srcRect[2] / (OWFfloat) dstRect->width;

   931     dy = (OWFfloat) srcRect[3] / (OWFfloat) dstRect->height;

   932 

   933     for (y = 0; y < dstRect->height; y++)

   934     {

   935         for (x = 0; x < dstRect->width; x++) 

   936         {

   937             OWFpixel*       pixel;         

   938             

   939             /* NOTE This code uses pixel center points to calculate distances

   940                     and factors. Results can differ slightly when pixel corner

   941                     coordinates are used */            

   942             

   943             /* coordinates of nearest pixel in original image */

   944             ox = (int) floor((((OWFfloat) x + 0.5) * dx) + srcRect[0]);

   945             oy = (int) floor((((OWFfloat) y + 0.5) * dy) + srcRect[1]);     

   946             

   947             pixel = OWF_Image_GetPixelPtr(src,

   948                                           ox,

   949                                           oy);

   950             

   951             OWF_Image_SetPixel(dst,

   952                                dstRect->x + x,

   953                                dstRect->y + y,

   954                                pixel);

   955             

   956         }

   957     }

   958     return OWF_TRUE;

   959 }

   960 

   961 /*----------------------------------------------------------------------------*/

   962 OWF_API_CALL OWFboolean

   963 OWF_Image_BilinearStretchBlit(OWF_IMAGE* dst,

   964                               OWF_RECTANGLE* dstRect,

   965                               OWF_IMAGE* src,

   966                               OWFfloat* srcRect)

   967 {

   968     OWFint                  x = 0, y = 0;

   969     OWFint                  ox = 0, oy = 0;

   970     OWFfloat                dx = 0.f, dy = 0.f, wx = 0.f, wy = 0.f;

   971     OWFfloat                w[2 * 2];

   972     OWFpixel*               sample[4];

   973     OWFpixel*               pixel = NULL;

   974 

   975     /* images must be valid */

   976     if (!((src != NULL) && (src->data != NULL) &&

   977           (dst != NULL) && (dst->data != NULL)))

   978     {

   979         return OWF_FALSE;

   980     }

   981     OWF_ASSERT(src->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   982     OWF_ASSERT(dst->format.pixelFormat==OWF_IMAGE_ARGB_INTERNAL);

   983 

   984     /* ditto with rectangles, too */

   985     if (!((dstRect != NULL) && (dstRect->width && dstRect->height) &&

   986           (srcRect != NULL) && (srcRect[2] && srcRect[3])))

   987     {

   988         return OWF_FALSE;

   989     }

   990 

   991     if (src->pixelSize != dst->pixelSize)

   992     {

   993         return OWF_FALSE;

   994     }

   995 

   996     /* solve scaling ratios for image */

   997     dx = (OWFfloat) srcRect[2] / (OWFfloat) dstRect->width;

   998     dy = (OWFfloat) srcRect[3] / (OWFfloat) dstRect->height;

   999 

  1000     for (y = 0; y < dstRect->height; y++)

  1001     {

  1002         for (x = 0; x < dstRect->width; x++)

  1003         {

  1004             OWFfloat tempOx, tempOy;            

  1005             

  1006             /* NOTE This code uses pixel center points to calculate distances

  1007                     and factors. Results can differ slightly when pixel corner

  1008                     coordinates are used */

  1009 

  1010             /* coordinates of nearest pixel in original image */

  1011             tempOx = (((OWFfloat) x + 0.5) * dx) + srcRect[0];

  1012             tempOy = (((OWFfloat) y + 0.5) * dy) + srcRect[1];            

  1013             

  1014             ox = (int) floor((((OWFfloat) x + 0.5) * dx) + srcRect[0]);

  1015             oy = (int) floor((((OWFfloat) y + 0.5) * dy) + srcRect[1]);    

  1016 

  1017             /* Distances to nearest pixel, eg. fractional part of coordinate */    

  1018             wx = (OWFfloat) ox + 0.5 - tempOx;

  1019             wy = (OWFfloat) oy + 0.5 - tempOy;

  1020 

  1021             /* If distance is positive, we should use left or upper pixel for

  1022              * second nearest pixel. */

  1023             if (wx > 0.0)

  1024             {

  1025                 ox--;

  1026                 wx = 1.0 - wx;

  1027             }

  1028             else

  1029             {

  1030                 wx = -wx; /* abs */

  1031             }

  1032 

  1033             if (wy > 0.0)

  1034             {

  1035                 oy--;

  1036                 wy = 1.0 - wy;

  1037             }

  1038             else

  1039             {

  1040                 wy = -wy;

  1041             }

  1042             

  1043             /* Calculate weights for samples */

  1044             w[0] = (1.0 - wx) * (1.0 - wy);

  1045             w[1] = wx * (1.0 - wy);

  1046             w[2] = (1.0 - wx) * wy;

  1047             w[3] = wx * wy;

  1048 

  1049             /* get sample */

  1050             sample[0] = OWF_Image_GetPixelPtr(src, ox + 0, oy + 0);

  1051             sample[1] = OWF_Image_GetPixelPtr(src, ox + 1, oy + 0);

  1052             sample[2] = OWF_Image_GetPixelPtr(src, ox + 0, oy + 1);

  1053             sample[3] = OWF_Image_GetPixelPtr(src, ox + 1, oy + 1);

  1054 

  1055             

  1056             /* get result pixel */

  1057             pixel = OWF_Image_GetPixelPtr(dst, x, y);

  1058 

  1059             /* calculate final color */

  1060             pixel->color.red   =

  1061                 sample[0]->color.red * w[0] + sample[1]->color.red * w[1] +

  1062                 sample[2]->color.red * w[2] + sample[3]->color.red * w[3] + OWF_BILINEAR_ROUNDING_VALUE;

  1063 

  1064             pixel->color.green =

  1065                 sample[0]->color.green * w[0] + sample[1]->color.green * w[1] +

  1066                 sample[2]->color.green * w[2] + sample[3]->color.green * w[3] + OWF_BILINEAR_ROUNDING_VALUE;

  1067 

  1068             pixel->color.blue  =

  1069                 sample[0]->color.blue * w[0] + sample[1]->color.blue * w[1] +

  1070                 sample[2]->color.blue * w[2] + sample[3]->color.blue * w[3] + OWF_BILINEAR_ROUNDING_VALUE;

  1071 

  1072             pixel->color.alpha =

  1073                 sample[0]->color.alpha * w[0] + sample[1]->color.alpha * w[1] +

  1074                 sample[2]->color.alpha * w[2] + sample[3]->color.alpha * w[3] + OWF_BILINEAR_ROUNDING_VALUE;

  1075         }

  1076     }

  1077     return OWF_TRUE;

  1078 

  1079 }

  1080 

  1081 /*----------------------------------------------------------------------------*/

  1082 OWF_API_CALL OWFboolean

  1083 OWF_Image_Stretch(OWF_IMAGE* dst,

  1084                   OWF_RECTANGLE* dstRect,

  1085                   OWF_IMAGE* src,

  1086                   OWFfloat* srcRect,

  1087                   OWF_FILTERING filter)

  1088 {

  1089     OWFboolean          result = OWF_FALSE;

  1090 

  1091     switch (filter)

  1092     {

  1093         case OWF_FILTER_POINT_SAMPLING:

  1094         {

  1095             result = OWF_Image_PointSamplingStretchBlit(dst, dstRect, src,

  1096                                                         srcRect);

  1097             break;

  1098         }

  1099         case OWF_FILTER_BILINEAR:

  1100         {

  1101             result = OWF_Image_BilinearStretchBlit(dst, dstRect, src, srcRect);

  1102             break;

  1103         }

  1104     }

  1105 

  1106     return result;

  1107 }

  1108 

  1109 /*----------------------------------------------------------------------------*/

  1110 OWF_API_CALL void

  1111 OWF_Image_Clear(OWF_IMAGE* image,

  1112                 OWFsubpixel red,

  1113                 OWFsubpixel green,

  1114                 OWFsubpixel blue,

  1115                 OWFsubpixel alpha)

  1116 {

  1117     OWFint                  i, numPixels;

  1118     OWFpixel*                pixels;

  1119 

  1120     OWF_ASSERT(image != 0);

  1121     OWF_ASSERT(image->data != 0);

  1122     OWF_ASSERT(image->format.pixelFormat == OWF_IMAGE_ARGB_INTERNAL);

  1123 

  1124     numPixels = image->width * image->height;

  1125     pixels = (OWFpixel*) image->data;

  1126 

  1127     for (i = 0; i < numPixels; i++)

  1128     {

  1129         pixels[i].color.red   = (OWFsubpixel) red;

  1130         pixels[i].color.green = (OWFsubpixel) green;

  1131         pixels[i].color.blue  = (OWFsubpixel) blue;

  1132         pixels[i].color.alpha = (OWFsubpixel) alpha;

  1133     }