libmng_pixels.c

奇趣公司比较新的qt/emd版本

      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {                              /* get alpha values */
          if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
          {                            /* fully opaque or background fully transparent ? */
            if (s == 255)
            {                          /* plain copy it */
              pScanline[0] = pDataline[0];
              pScanline[1] = pDataline[2];
              pScanline[2] = pDataline[4];
              pScanline[3] = 255;
            }
            else
            {                          /* now blend (premultiplied) */
			  t = 255 - s;
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
              {
                int i;
                for (i=2; i >= 0; i--)
                {
                  pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
                     pScanline[2-i]);
                }
              }
#else
              pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
              pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
			  pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
#endif
              pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
            }
          }

          pScanline += (pData->iColinc << 2);
          pDataline += 8;
        }
      }
      else
#endif
      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {
          if ((s = pDataline[3]) != 0) /* any opacity at all ? */
          {                            /* fully opaque ? */
            if (s == 255)
            {                          /* then simply copy the values */
#ifdef MNG_BIGENDIAN_SUPPORTED
              *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
#else
              pScanline[0] = pDataline[0];
              pScanline[1] = pDataline[1];
              pScanline[2] = pDataline[2];
              pScanline[3] = 255;
#endif
            }
            else
            {                          /* now blend (premultiplied) */
			  t = 255 - s;
#ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
              {
                int i;
                for (i=2; i >= 0; i--)
                {
                  pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
                     pScanline[2-i]);
                }
              }
#else
              pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
              pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
			  pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
#endif
              pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
            }
          }

          pScanline += (pData->iColinc << 2);
          pDataline += 4;
        }
      }
    }
  }

  check_update_region (pData);

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
#endif

  return MNG_NOERROR;
}
#endif /* MNG_SKIPCANVAS_RGBA8_PM */

/* ************************************************************************** */

#ifndef MNG_SKIPCANVAS_ARGB8
mng_retcode mng_display_argb8 (mng_datap pData)
{
  mng_uint8p pScanline;
  mng_uint8p pDataline;
  mng_int32  iX;
  mng_uint8  iFGa8, iBGa8, iCa8;
#ifndef MNG_NO_16BIT_SUPPORT
  mng_uint16 iFGa16, iBGa16, iCa16;
#ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
  mng_uint16 iFGr16, iFGg16, iFGb16;
#else
  mng_uint16 iFGg16;
#endif
  mng_uint16 iBGr16, iBGg16, iBGb16;
  mng_uint16 iCr16, iCg16, iCb16;
#endif  
  mng_uint8  iCr8, iCg8, iCb8;

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
#endif

                                       /* viewable row ? */
  if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
  {                                    /* address destination row */
    pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
                                                   pData->iRow + pData->iDestt -
                                                   pData->iSourcet);
                                       /* adjust destination row starting-point */
    pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    pDataline = pData->pRGBArow;       /* address source row */

#ifndef MNG_NO_16BIT_SUPPORT
    if (pData->bIsRGBA16)              /* adjust source row starting-point */
      pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    else
#endif
      pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);

    if (pData->bIsOpaque)              /* forget about transparency ? */
    {
#ifndef MNG_NO_16BIT_SUPPORT
      if (pData->bIsRGBA16)            /* 16-bit input row ? */
      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {                              /* scale down by dropping the LSB */
          *pScanline     = *(pDataline+6);
          *(pScanline+1) = *pDataline;
          *(pScanline+2) = *(pDataline+2);
          *(pScanline+3) = *(pDataline+4);

          pScanline += (pData->iColinc << 2);
          pDataline += 8;
        }
      }
      else
#endif
      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {                              /* copy the values */
          *pScanline     = *(pDataline+3);
          *(pScanline+1) = *pDataline;
          *(pScanline+2) = *(pDataline+1);
          *(pScanline+3) = *(pDataline+2);

          pScanline += (pData->iColinc << 2);
          pDataline += 4;
        }
      }
    }
    else
    {
#ifndef MNG_NO_16BIT_SUPPORT
      if (pData->bIsRGBA16)            /* 16-bit input row ? */
      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {                              /* get alpha values */
          iFGa16 = mng_get_uint16 (pDataline+6);
          iBGa16 = (mng_uint16)(*pScanline);
          iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;

          if (iFGa16)                  /* any opacity at all ? */
          {                            /* fully opaque or background fully transparent ? */
            if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
            {                          /* plain copy it */
              *pScanline     = *(pDataline+6);
              *(pScanline+1) = *pDataline;
              *(pScanline+2) = *(pDataline+2);
              *(pScanline+3) = *(pDataline+4);
            }
            else
            {
              if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
              {                        /* get the proper values */
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
              int i;
              for (i=2; i >= 0; i--)
              {
                iFGg16 = mng_get_uint16 (pDataline+i+i);
                                       /* scale background up */
                iBGg16 = (mng_uint16)(*(pScanline+i+1));
                iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
                                       /* now compose */
                MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
                                       /* and return the composed values */
                                       /* alpha remains fully opaque !!! */
                *(pScanline+i+1) = (mng_uint8)(iFGg16 >> 8);
              }
#else
                iFGr16 = mng_get_uint16 (pDataline  );
                iFGg16 = mng_get_uint16 (pDataline+2);
                iFGb16 = mng_get_uint16 (pDataline+4);
                                       /* scale background up */
                iBGr16 = (mng_uint16)(*(pScanline+1));
                iBGg16 = (mng_uint16)(*(pScanline+2));
                iBGb16 = (mng_uint16)(*(pScanline+3));
                iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
                iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
                iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
                                       /* now compose */
                MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
                MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
                MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
                                       /* and return the composed values */
                                       /* alpha remains fully opaque !!! */
                *(pScanline+1) = (mng_uint8)(iFGr16 >> 8);
                *(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
                *(pScanline+3) = (mng_uint8)(iFGb16 >> 8);
#endif
              }
              else
              {                        /* scale background up */
                iBGr16 = (mng_uint16)(*(pScanline+1));
                iBGg16 = (mng_uint16)(*(pScanline+2));
                iBGb16 = (mng_uint16)(*(pScanline+3));
                iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
                iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
                iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
                                       /* let's blend */
                MNG_BLEND16 (mng_get_uint16 (pDataline  ),
                             mng_get_uint16 (pDataline+2),
                             mng_get_uint16 (pDataline+4), iFGa16,
                             iBGr16, iBGg16, iBGb16, iBGa16,
                             iCr16,  iCg16,  iCb16,  iCa16);
                                       /* and return the composed values */
                *pScanline     = (mng_uint8)(iCa16 >> 8);
                *(pScanline+1) = (mng_uint8)(iCr16 >> 8);
                *(pScanline+2) = (mng_uint8)(iCg16 >> 8);
                *(pScanline+3) = (mng_uint8)(iCb16 >> 8);
              }
            }
          }

          pScanline += (pData->iColinc << 2);
          pDataline += 8;
        }
      }
      else
#endif
      {
        for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer; iX += pData->iColinc)
        {
          iFGa8 = *(pDataline+3);      /* get alpha values */
          iBGa8 = *pScanline;

          if (iFGa8)                   /* any opacity at all ? */
          {                            /* fully opaque or background fully transparent ? */
            if ((iFGa8 == 0xFF) || (iBGa8 == 0))
            {                          /* then simply copy the values */
              *pScanline     = *(pDataline+3);
              *(pScanline+1) = *pDataline;
              *(pScanline+2) = *(pDataline+1);
              *(pScanline+3) = *(pDataline+2);
            }
            else
            {
              if (iBGa8 == 0xFF)       /* background fully opaque ? */
              {                        /* do simple alpha composing */
                                       /* alpha itself remains fully opaque !!! */
#ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
              int i;
              for (i=2; i >= 0; i--)
              {
              MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+i), iFGa8, *(pScanline+i+1));
              }
#else
                MNG_COMPOSE8 (*(pScanline+1), *pDataline,     iFGa8, *(pScanline+1));
                MNG_COMPOSE8 (*(pScanline+2), *(pDataline+1), iFGa8, *(pScanline+2));
                MNG_COMPOSE8 (*(pScanline+3), *(pDataline+2), iFGa8, *(pScanline+3));
#endif
              }
              else
              {                        /* now blend */
                MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
                            *(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
                            iCr8, iCg8, iCb8, iCa8);