TB9.2 Example Applications: examples/PIPS/antiword/src/dib2sprt.c Source File

00001 /*
+00002  * dib2sprt.c
+00003  * Copyright (C) 2000-2003 A.J. van Os; Released under GPL
+00004  *
+00005  * Description:
+00006  * Functions to translate dib pictures into sprites
+00007  */
+00008 
+00009 #include <stdio.h>
+00010 #include <string.h>
+00011 #include "DeskLib:Error.h"
+00012 #include "DeskLib:Sprite.h"
+00013 #include "antiword.h"
+00014 
+00015 #if 0 /* defined(DEBUG) */
+00016 static int iPicCounter = 0;
+00017 #endif /* DEBUG */
+00018 
+00019 
+00020 /*
+00021  * iGetByteWidth - compute the number of bytes needed for a row of pixels
+00022  */
+00023 static int
+00024 iGetByteWidth(const imagedata_type *pImg)
+00025 {
+00026         switch (pImg->uiBitsPerComponent) {
+00027         case  1:
+00028                 return (pImg->iWidth + 31) / 32 * sizeof(int);
+00029         case  4:
+00030                 return (pImg->iWidth + 7) / 8 * sizeof(int);
+00031         case  8:
+00032         case 24:
+00033                 return (pImg->iWidth + 3) / 4 * sizeof(int);
+00034         default:
+00035                 DBG_DEC(pImg->uiBitsPerComponent);
+00036                 return 0;
+00037         }
+00038 } /* end of iGetByteWidth */
+00039 
+00040 /*
+00041  * pCreateBlankSprite - Create a blank sprite.
+00042  *
+00043  * Create a blank sprite and add a palette if needed
+00044  *
+00045  * returns a pointer to the sprite when successful, otherwise NULL
+00046  */
+00047 static sprite_areainfo *
+00048 pCreateBlankSprite(const imagedata_type *pImg, size_t *pSize)
+00049 {
+00050         sprite_areainfo *pArea;
+00051         UCHAR   *pucTmp;
+00052         size_t  tSize;
+00053         screen_modeval  uMode;
+00054         int     iIndex, iPaletteEntries;
+00055 
+00056         TRACE_MSG("pCreateBlankSprite");
+00057 
+00058         fail(pImg == NULL);
+00059         fail(pSize == NULL);
+00060 
+00061         switch (pImg->uiBitsPerComponent) {
+00062         case  1:
+00063                 uMode.screen_mode = 18;
+00064                 iPaletteEntries = 2;
+00065                 break;
+00066         case  4:
+00067                 uMode.screen_mode = 20;
+00068                 iPaletteEntries = 16;
+00069                 break;
+00070         case  8:
+00071         case 24:
+00072                 uMode.screen_mode = 21;
+00073                 iPaletteEntries = 0;
+00074                 break;
+00075         default:
+00076                 DBG_DEC(pImg->uiBitsPerComponent);
+00077                 return NULL;
+00078         }
+00079         fail(iPaletteEntries < 0 || iPaletteEntries > 16);
+00080 
+00081         /* Get memory for the sprite */
+00082         tSize = sizeof(sprite_areainfo) +
+00083                 Sprite_MemorySize(pImg->iWidth, pImg->iHeight, uMode,
+00084                 iPaletteEntries > 0 ? sprite_HASPAL : sprite_HASNOMASKPAL);
+00085         DBG_DEC(tSize);
+00086         pArea = xmalloc(tSize);
+00087 
+00088         /* Initialise sprite area */
+00089         pArea->areasize = tSize;
+00090         pArea->numsprites = 0;
+00091         pArea->firstoffset = sizeof(sprite_areainfo);
+00092         pArea->freeoffset = sizeof(sprite_areainfo);
+00093 
+00094         /* Create a blank sprite */
+00095         Error_CheckFatal(Sprite_Create(pArea, "wordimage",
+00096                 iPaletteEntries > 0 ? 1 : 0,
+00097                 pImg->iWidth, pImg->iHeight, uMode));
+00098 
+00099         /* Add the palette */
+00100         pucTmp = (UCHAR *)pArea + pArea->firstoffset + sizeof(sprite_header);
+00101         for (iIndex = 0; iIndex < iPaletteEntries; iIndex++) {
+00102                 /* First color */
+00103                 *pucTmp++ = 0;
+00104                 *pucTmp++ = pImg->aucPalette[iIndex][0];
+00105                 *pucTmp++ = pImg->aucPalette[iIndex][1];
+00106                 *pucTmp++ = pImg->aucPalette[iIndex][2];
+00107                 /* Second color */
+00108                 *pucTmp++ = 0;
+00109                 *pucTmp++ = pImg->aucPalette[iIndex][0];
+00110                 *pucTmp++ = pImg->aucPalette[iIndex][1];
+00111                 *pucTmp++ = pImg->aucPalette[iIndex][2];
+00112         }
+00113 
+00114         *pSize = tSize;
+00115         return pArea;
+00116 } /* end of pCreateBlankSprite */
+00117 
+00118 /*
+00119  * iReduceColor - reduce from 24 bit to 8 bit color
+00120  *
+00121  * Reduce 24 bit true colors to RISC OS default 256 color palette
+00122  *
+00123  * returns the resulting color
+00124  */
+00125 static int
+00126 iReduceColor(int iRed, int iGreen, int iBlue)
+00127 {
+00128         int     iResult;
+00129 
+00130         iResult = (iBlue & 0x80) ? 0x80 : 0;
+00131         iResult |= (iGreen & 0x80) ? 0x40 : 0;
+00132         iResult |= (iGreen & 0x40) ? 0x20 : 0;
+00133         iResult |= (iRed & 0x80) ? 0x10 : 0;
+00134         iResult |= (iBlue & 0x40) ? 0x08 : 0;
+00135         iResult |= (iRed & 0x40) ? 0x04 : 0;
+00136         iResult |= ((iRed | iGreen | iBlue) & 0x20) ? 0x02 : 0;
+00137         iResult |= ((iRed | iGreen | iBlue) & 0x10) ? 0x01 : 0;
+00138         return iResult;
+00139 } /* end of iReduceColor */
+00140 
+00141 /*
+00142  * vDecode1bpp - decode an uncompressed 1 bit per pixel image
+00143  */
+00144 static void
+00145 vDecode1bpp(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00146 {
+00147         int     iX, iY, iByteWidth, iOffset, iTmp, iEighthWidth, iPadding;
+00148         UCHAR   ucTmp;
+00149 
+00150         DBG_MSG("vDecode1bpp");
+00151 
+00152         fail(pFile == NULL);
+00153         fail(pucData == NULL);
+00154         fail(pImg == NULL);
+00155         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 2);
+00156 
+00157         iByteWidth = iGetByteWidth(pImg);
+00158 
+00159         iEighthWidth = (pImg->iWidth + 7) / 8;
+00160         iPadding = ROUND4(iEighthWidth) - iEighthWidth;
+00161 
+00162         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00163                 for (iX = 0; iX < iEighthWidth; iX++) {
+00164                         iTmp = iNextByte(pFile);
+00165                         if (iTmp == EOF) {
+00166                                 return;
+00167                         }
+00168                         /* Reverse the bit order */
+00169                         ucTmp  = (iTmp & BIT(0)) ? (UCHAR)BIT(7) : 0;
+00170                         ucTmp |= (iTmp & BIT(1)) ? (UCHAR)BIT(6) : 0;
+00171                         ucTmp |= (iTmp & BIT(2)) ? (UCHAR)BIT(5) : 0;
+00172                         ucTmp |= (iTmp & BIT(3)) ? (UCHAR)BIT(4) : 0;
+00173                         ucTmp |= (iTmp & BIT(4)) ? (UCHAR)BIT(3) : 0;
+00174                         ucTmp |= (iTmp & BIT(5)) ? (UCHAR)BIT(2) : 0;
+00175                         ucTmp |= (iTmp & BIT(6)) ? (UCHAR)BIT(1) : 0;
+00176                         ucTmp |= (iTmp & BIT(7)) ? (UCHAR)BIT(0) : 0;
+00177                         iOffset = iY * iByteWidth + iX;
+00178                         *(pucData + iOffset) = ucTmp;
+00179                 }
+00180                 (void)tSkipBytes(pFile, iPadding);
+00181         }
+00182 } /* end of vDecode1bpp */
+00183 
+00184 /*
+00185  * vDecode4bpp - decode an uncompressed 4 bits per pixel image
+00186  */
+00187 static void
+00188 vDecode4bpp(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00189 {
+00190         int     iX, iY, iByteWidth, iOffset, iTmp, iHalfWidth, iPadding;
+00191         UCHAR   ucTmp;
+00192 
+00193         DBG_MSG("vDecode4bpp");
+00194 
+00195         fail(pFile == NULL);
+00196         fail(pucData == NULL);
+00197         fail(pImg == NULL);
+00198         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
+00199 
+00200         iByteWidth = iGetByteWidth(pImg);
+00201 
+00202         iHalfWidth = (pImg->iWidth + 1) / 2;
+00203         iPadding = ROUND4(iHalfWidth) - iHalfWidth;
+00204 
+00205         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00206                 for (iX = 0; iX < iHalfWidth; iX++) {
+00207                         iTmp = iNextByte(pFile);
+00208                         if (iTmp == EOF) {
+00209                                 return;
+00210                         }
+00211                         /* Reverse the nibble order */
+00212                         ucTmp = (iTmp & 0xf0) >> 4;
+00213                         ucTmp |= (iTmp & 0x0f) << 4;
+00214                         iOffset = iY * iByteWidth + iX;
+00215                         *(pucData + iOffset) = ucTmp;
+00216                 }
+00217                 (void)tSkipBytes(pFile, iPadding);
+00218         }
+00219 } /* end of vDecode4bpp */
+00220 
+00221 /*
+00222  * vDecode8bpp - decode an uncompressed 8 bits per pixel image
+00223  */
+00224 static void
+00225 vDecode8bpp(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00226 {
+00227         int     iX, iY, iByteWidth, iOffset, iIndex, iPadding;
+00228 
+00229         DBG_MSG("vDecode8bpp");
+00230 
+00231         fail(pFile == NULL);
+00232         fail(pucData == NULL);
+00233         fail(pImg == NULL);
+00234         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
+00235 
+00236         iByteWidth = iGetByteWidth(pImg);
+00237 
+00238         iPadding = ROUND4(pImg->iWidth) - pImg->iWidth;
+00239 
+00240         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00241                 for (iX = 0; iX < pImg->iWidth; iX++) {
+00242                         iIndex = iNextByte(pFile);
+00243                         if (iIndex == EOF) {
+00244                                 return;
+00245                         }
+00246                         iOffset = iY * iByteWidth + iX;
+00247                         *(pucData + iOffset) = iReduceColor(
+00248                                 pImg->aucPalette[iIndex][0],
+00249                                 pImg->aucPalette[iIndex][1],
+00250                                 pImg->aucPalette[iIndex][2]);
+00251                 }
+00252                 (void)tSkipBytes(pFile, iPadding);
+00253         }
+00254 } /* end of vDecode8bpp */
+00255 
+00256 /*
+00257  * vDecode24bpp - decode an uncompressed 24 bits per pixel image
+00258  */
+00259 static void
+00260 vDecode24bpp(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00261 {
+00262         int     iX, iY, iTripleWidth, iByteWidth, iOffset, iPadding;
+00263         int     iRed, iGreen, iBlue;
+00264 
+00265         DBG_MSG("vDecode24bpp");
+00266 
+00267         fail(pFile == NULL);
+00268         fail(pucData == NULL);
+00269         fail(pImg == NULL);
+00270 
+00271         iByteWidth = iGetByteWidth(pImg);
+00272 
+00273         iTripleWidth = pImg->iWidth * 3;
+00274         iPadding = ROUND4(iTripleWidth) - iTripleWidth;
+00275 
+00276         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00277                 for (iX = 0; iX < pImg->iWidth; iX++) {
+00278                         iBlue = iNextByte(pFile);
+00279                         if (iBlue == EOF) {
+00280                                 return;
+00281                         }
+00282                         iGreen = iNextByte(pFile);
+00283                         if (iGreen == EOF) {
+00284                                 return;
+00285                         }
+00286                         iRed = iNextByte(pFile);
+00287                         if (iRed == EOF) {
+00288                                 return;
+00289                         }
+00290                         iOffset = iY * iByteWidth + iX;
+00291                         *(pucData + iOffset) =
+00292                                         iReduceColor(iRed, iGreen, iBlue);
+00293                 }
+00294                 (void)tSkipBytes(pFile, iPadding);
+00295         }
+00296 } /* end of vDecode24bpp */
+00297 
+00298 /*
+00299  * vDecodeRle4 - decode a RLE compressed 4 bits per pixel image
+00300  */
+00301 static void
+00302 vDecodeRle4(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00303 {
+00304         int     iX, iY, iByteWidth, iOffset, iTmp, iHalfWidth;
+00305         int     iRun, iRunLength, iHalfRun;
+00306         BOOL    bEOL;
+00307         UCHAR   ucTmp;
+00308 
+00309         DBG_MSG("vDecodeRle4");
+00310 
+00311         fail(pFile == NULL);
+00312         fail(pucData == NULL);
+00313         fail(pImg == NULL);
+00314         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
+00315 
+00316         DBG_DEC(pImg->iWidth);
+00317         DBG_DEC(pImg->iHeight);
+00318 
+00319         iByteWidth = iGetByteWidth(pImg);
+00320         iHalfWidth = (pImg->iWidth + 1) / 2;
+00321 
+00322         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00323                 bEOL = FALSE;
+00324                 iX = 0;
+00325                 while (!bEOL) {
+00326                         iRunLength = iNextByte(pFile);
+00327                         if (iRunLength == EOF) {
+00328                                 return;
+00329                         }
+00330                         if (iRunLength != 0) {
+00331                                 /*
+00332                                  * Encoded packet:
+00333                                  * RunLength pixels, all the "same" value
+00334                                  */
+00335                                 iTmp = iNextByte(pFile);
+00336                                 if (iTmp == EOF) {
+00337                                         return;
+00338                                 }
+00339                                 /* Reverse the nibble order */
+00340                                 ucTmp = (iTmp & 0xf0) >> 4;
+00341                                 ucTmp |= (iTmp & 0x0f) << 4;
+00342                                 iHalfRun = (iRunLength + 1) / 2;
+00343                                 for (iRun = 0; iRun < iHalfRun; iRun++) {
+00344                                         if (iX < iHalfWidth) {
+00345                                                 iOffset = iY * iByteWidth + iX;
+00346                                                 *(pucData + iOffset) = ucTmp;
+00347                                         }
+00348                                         iX++;
+00349                                 }
+00350                                 continue;
+00351                         }
+00352                         /* Literal or escape */
+00353                         iRunLength = iNextByte(pFile);
+00354                         if (iRunLength == EOF) {
+00355                                 return;
+00356                         }
+00357                         if (iRunLength == 0) {          /* End of line escape */
+00358                                 bEOL = TRUE;
+00359                         } else if (iRunLength == 1) {   /* End of file escape */
+00360                                 return;
+00361                         } else if (iRunLength == 2) {   /* Delta escape */
+00362                                 DBG_MSG("RLE4: encountered delta escape");
+00363                                 return;
+00364                         } else {                        /* Literal packet */
+00365                                 iHalfRun = (iRunLength + 1) / 2;
+00366                                 for (iRun = 0; iRun < iHalfRun; iRun++) {
+00367                                         iTmp = iNextByte(pFile);
+00368                                         if (iTmp == EOF) {
+00369                                                 return;
+00370                                         }
+00371                                         /* Reverse the nibble order */
+00372                                         ucTmp = (iTmp & 0xf0) >> 4;
+00373                                         ucTmp |= (iTmp & 0x0f) << 4;
+00374                                         if (iX < iHalfWidth) {
+00375                                                 iOffset = iY * iByteWidth + iX;
+00376                                                 *(pucData + iOffset) = ucTmp;
+00377                                         }
+00378                                         iX++;
+00379                                 }
+00380                                 /* Padding if the number of bytes is odd */
+00381                                 if (odd(iHalfRun)) {
+00382                                         (void)tSkipBytes(pFile, 1);
+00383                                 }
+00384                         }
+00385                 }
+00386                 DBG_DEC_C(iX != iHalfWidth, iX);
+00387         }
+00388 } /* end of vDecodeRle4 */
+00389 
+00390 /*
+00391  * vDecodeRle8 - decode a RLE compressed 8 bits per pixel image
+00392  */
+00393 static void
+00394 vDecodeRle8(FILE *pFile, UCHAR *pucData, const imagedata_type *pImg)
+00395 {
+00396         int     iX, iY, iRun, iRunLength, iOffset, iIndex, iByteWidth;
+00397         BOOL    bEOL;
+00398 
+00399         DBG_MSG("vDecodeRle8");
+00400 
+00401         fail(pFile == NULL);
+00402         fail(pucData == NULL);
+00403         fail(pImg == NULL);
+00404         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
+00405 
+00406         DBG_DEC(pImg->iWidth);
+00407         DBG_DEC(pImg->iHeight);
+00408 
+00409         iByteWidth = iGetByteWidth(pImg);
+00410 
+00411         for (iY = pImg->iHeight - 1; iY >= 0; iY--) {
+00412                 bEOL = FALSE;
+00413                 iX = 0;
+00414                 while (!bEOL) {
+00415                         iRunLength = iNextByte(pFile);
+00416                         if (iRunLength == EOF) {
+00417                                 return;
+00418                         }
+00419                         if (iRunLength != 0) {
+00420                                 /*
+00421                                  * Encoded packet:
+00422                                  * RunLength pixels, all the same value
+00423                                  */
+00424                                 iIndex = iNextByte(pFile);
+00425                                 if (iIndex == EOF) {
+00426                                         return;
+00427                                 }
+00428                                 for (iRun = 0; iRun < iRunLength; iRun++) {
+00429                                         if (iX < pImg->iWidth) {
+00430                                                 iOffset = iY * iByteWidth + iX;
+00431                                                 *(pucData + iOffset) =
+00432                                                         iReduceColor(
+00433                                                         pImg->aucPalette[iIndex][0],
+00434                                                         pImg->aucPalette[iIndex][1],
+00435                                                         pImg->aucPalette[iIndex][2]);
+00436                                         }
+00437                                         iX++;
+00438                                 }
+00439                                 continue;
+00440                         }
+00441                         /* Literal or escape */
+00442                         iRunLength = iNextByte(pFile);
+00443                         if (iRunLength == EOF) {
+00444                                 return;
+00445                         }
+00446                         if (iRunLength == 0) {          /* End of line escape */
+00447                                 bEOL = TRUE;
+00448                         } else if (iRunLength == 1) {   /* End of file escape */
+00449                                 return;
+00450                         } else if (iRunLength == 2) {   /* Delta escape */
+00451                                 DBG_MSG("RLE8: encountered delta escape");
+00452                                 return;
+00453                         } else {                        /* Literal packet */
+00454                                 for (iRun = 0; iRun < iRunLength; iRun++) {
+00455                                         iIndex = iNextByte(pFile);
+00456                                         if (iIndex == EOF) {
+00457                                                 return;
+00458                                         }
+00459                                         if (iX < pImg->iWidth) {
+00460                                                 iOffset = iY * iByteWidth + iX;
+00461                                                 *(pucData + iOffset) =
+00462                                                         iReduceColor(
+00463                                                         pImg->aucPalette[iIndex][0],
+00464                                                         pImg->aucPalette[iIndex][1],
+00465                                                         pImg->aucPalette[iIndex][2]);
+00466                                         }
+00467                                         iX++;
+00468                                 }
+00469                                 /* Padding if the number of bytes is odd */
+00470                                 if (odd(iRunLength)) {
+00471                                         (void)tSkipBytes(pFile, 1);
+00472                                 }
+00473                         }
+00474                 }
+00475                 DBG_DEC_C(iX != pImg->iWidth, iX);
+00476         }
+00477 } /* end of vDecodeRle8 */
+00478 
+00479 #if 0 /* defined(DEBUG) */
+00480 static void
+00481 vCopy2File(UCHAR *pucSprite, size_t tSpriteSize)
+00482 {
+00483         FILE    *pOutFile;
+00484         int     iIndex;
+00485         char    szFilename[30];
+00486 
+00487         sprintf(szFilename, "<Wimp$ScrapDir>.sprt%04d", ++iPicCounter);
+00488         pOutFile = fopen(szFilename, "wb");
+00489         if (pOutFile == NULL) {
+00490                 return;
+00491         }
+00492         DBG_MSG(szFilename);
+00493         for (iIndex = 4; iIndex < (int)tSpriteSize; iIndex++) {
+00494                 if (putc(pucSprite[iIndex], pOutFile) == EOF) {
+00495                         break;
+00496                 }
+00497         }
+00498         (void)fclose(pOutFile);
+00499         vSetFiletype(szFilename, FILETYPE_SPRITE);
+00500 } /* end of vCopy2File */
+00501 #endif /* DEBUG */
+00502 
+00503 /*
+00504  * vDecodeDIB - decode a dib picture
+00505  */
+00506 static void
+00507 vDecodeDIB(diagram_type *pDiag, FILE *pFile, const imagedata_type *pImg)
+00508 {
+00509         sprite_areainfo *pSprite;
+00510         UCHAR   *pucPalette, *pucData;
+00511         size_t  tSpriteSize;
+00512         int     iHeaderSize;
+00513 
+00514         /* Skip the bitmap info header */
+00515         iHeaderSize = (int)ulNextLong(pFile);
+00516         (void)tSkipBytes(pFile, iHeaderSize - 4);
+00517         /* Skip the colortable */
+00518         if (pImg->uiBitsPerComponent <= 8) {
+00519                 (void)tSkipBytes(pFile,
+00520                         pImg->iColorsUsed * ((iHeaderSize > 12) ? 4 : 3));
+00521         }
+00522 
+00523         /* Create an blank sprite */
+00524         pSprite = pCreateBlankSprite(pImg, &tSpriteSize);
+00525         pucPalette = (UCHAR *)pSprite +
+00526                         pSprite->firstoffset + sizeof(sprite_header);
+00527 
+00528         /* Add the pixel information */
+00529         switch (pImg->uiBitsPerComponent) {
+00530         case  1:
+00531                 fail(pImg->eCompression != compression_none);
+00532                 pucData = pucPalette + 2 * 8;
+00533                 vDecode1bpp(pFile, pucData, pImg);
+00534                 break;
+00535         case  4:
+00536                 fail(pImg->eCompression != compression_none &&
+00537                                 pImg->eCompression != compression_rle4);
+00538                 pucData = pucPalette + 16 * 8;
+00539                 if (pImg->eCompression == compression_rle4) {
+00540                         vDecodeRle4(pFile, pucData, pImg);
+00541                 } else {
+00542                         vDecode4bpp(pFile, pucData, pImg);
+00543                 }
+00544                 break;
+00545         case  8:
+00546                 fail(pImg->eCompression != compression_none &&
+00547                                 pImg->eCompression != compression_rle8);
+00548                 pucData = pucPalette + 0 * 8;
+00549                 if (pImg->eCompression == compression_rle8) {
+00550                         vDecodeRle8(pFile, pucData, pImg);
+00551                 } else {
+00552                         vDecode8bpp(pFile, pucData, pImg);
+00553                 }
+00554                 break;
+00555         case 24:
+00556                 fail(pImg->eCompression != compression_none);
+00557                 pucData = pucPalette + 0 * 8;
+00558                 vDecode24bpp(pFile, pucData, pImg);
+00559                 break;
+00560         default:
+00561                 DBG_DEC(pImg->uiBitsPerComponent);
+00562                 break;
+00563         }
+00564 
+00565 #if 0 /* defined(DEBUG) */
+00566         vCopy2File((UCHAR *)pSprite, tSpriteSize);
+00567 #endif /* DEBUG */
+00568 
+00569         /* Add the sprite to the Draw file */
+00570         vImage2Diagram(pDiag, pImg,
+00571                 (UCHAR *)pSprite + pSprite->firstoffset,
+00572                 tSpriteSize - pSprite->firstoffset);
+00573 
+00574         /* Clean up before you leave */
+00575         pSprite = xfree(pSprite);
+00576 } /* end of vDecodeDIB */
+00577 
+00578 /*
+00579  * bTranslateDIB - translate a DIB picture
+00580  *
+00581  * This function translates a picture from dib to sprite
+00582  *
+00583  * return TRUE when sucessful, otherwise FALSE
+00584  */
+00585 BOOL
+00586 bTranslateDIB(diagram_type *pDiag, FILE *pFile,
+00587         ULONG ulFileOffset, const imagedata_type *pImg)
+00588 {
+00589         /* Seek to start position of DIB data */
+00590         if (!bSetDataOffset(pFile, ulFileOffset)) {
+00591                 return FALSE;
+00592         }
+00593 
+00594         vDecodeDIB(pDiag, pFile, pImg);
+00595 
+00596         return TRUE;
+00597 } /* end of bTranslateDIB */
+