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

00001 /*
-00002  * dib2eps.c
-00003  * Copyright (C) 2000-2003 A.J. van Os; Released under GPL
-00004  *
-00005  * Description:
-00006  * Functions to translate dib pictures into eps
-00007  *
-00008  *================================================================
-00009  * This part of the software is based on:
-00010  * The Windows Bitmap Decoder Class part of paintlib
-00011  * Paintlib is copyright (c) 1996-2000 Ulrich von Zadow
-00012  *================================================================
-00013  * The credit should go to him, but all the bugs are mine.
-00014  */
-00015 
-00016 #include <stdio.h>
-00017 #include "antiword.h"
-00018 
-00019 
-00020 /*
-00021  * vDecode1bpp - decode an uncompressed 1 bit per pixel image
-00022  */
-00023 static void
-00024 vDecode1bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00025 {
-00026         size_t  tPadding;
-00027         int     iX, iY, iN, iByte, iTmp, iEighthWidth, iUse;
-00028 
-00029         DBG_MSG("vDecode1bpp");
-00030 
-00031         fail(pOutFile == NULL);
-00032         fail(pImg == NULL);
-00033         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 2);
-00034 
-00035         DBG_DEC(pImg->iWidth);
-00036         DBG_DEC(pImg->iHeight);
-00037 
-00038         iEighthWidth = (pImg->iWidth + 7) / 8;
-00039         tPadding = (size_t)(ROUND4(iEighthWidth) - iEighthWidth);
-00040 
-00041         for (iY = 0; iY < pImg->iHeight; iY++) {
-00042                 for (iX = 0; iX < iEighthWidth; iX++) {
-00043                         iByte = iNextByte(pInFile);
-00044                         if (iByte == EOF) {
-00045                                 vASCII85EncodeByte(pOutFile, EOF);
-00046                                 return;
-00047                         }
-00048                         if (iX == iEighthWidth - 1 && pImg->iWidth % 8 != 0) {
-00049                                 iUse = pImg->iWidth % 8;
-00050                         } else {
-00051                                 iUse = 8;
-00052                         }
-00053                         for (iN = 0; iN < iUse; iN++) {
-00054                                 switch (iN) {
-00055                                 case 0: iTmp = (iByte & 0x80) / 128; break;
-00056                                 case 1: iTmp = (iByte & 0x40) / 64; break;
-00057                                 case 2: iTmp = (iByte & 0x20) / 32; break;
-00058                                 case 3: iTmp = (iByte & 0x10) / 16; break;
-00059                                 case 4: iTmp = (iByte & 0x08) / 8; break;
-00060                                 case 5: iTmp = (iByte & 0x04) / 4; break;
-00061                                 case 6: iTmp = (iByte & 0x02) / 2; break;
-00062                                 case 7: iTmp = (iByte & 0x01); break;
-00063                                 default: iTmp = 0; break;
-00064                                 }
-00065                                 vASCII85EncodeByte(pOutFile, iTmp);
-00066                         }
-00067                 }
-00068                 (void)tSkipBytes(pInFile, tPadding);
-00069         }
-00070         vASCII85EncodeByte(pOutFile, EOF);
-00071 } /* end of vDecode1bpp */
-00072 
-00073 /*
-00074  * vDecode4bpp - decode an uncompressed 4 bits per pixel image
-00075  */
-00076 static void
-00077 vDecode4bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00078 {
-00079         size_t  tPadding;
-00080         int     iX, iY, iN, iByte, iTmp, iHalfWidth, iUse;
-00081 
-00082         DBG_MSG("vDecode4bpp");
-00083 
-00084         fail(pInFile == NULL);
-00085         fail(pOutFile == NULL);
-00086         fail(pImg == NULL);
-00087         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
-00088 
-00089         DBG_DEC(pImg->iWidth);
-00090         DBG_DEC(pImg->iHeight);
-00091 
-00092         iHalfWidth = (pImg->iWidth + 1) / 2;
-00093         tPadding = (size_t)(ROUND4(iHalfWidth) - iHalfWidth);
-00094 
-00095         for (iY = 0; iY < pImg->iHeight; iY++) {
-00096                 for (iX = 0; iX < iHalfWidth; iX++) {
-00097                         iByte = iNextByte(pInFile);
-00098                         if (iByte == EOF) {
-00099                                 vASCII85EncodeByte(pOutFile, EOF);
-00100                                 return;
-00101                         }
-00102                         if (iX == iHalfWidth - 1 && odd(pImg->iWidth)) {
-00103                                 iUse = 1;
-00104                         } else {
-00105                                 iUse = 2;
-00106                         }
-00107                         for (iN = 0; iN < iUse; iN++) {
-00108                                 if (odd(iN)) {
-00109                                         iTmp = iByte & 0x0f;
-00110                                 } else {
-00111                                         iTmp = (iByte & 0xf0) / 16;
-00112                                 }
-00113                                 vASCII85EncodeByte(pOutFile, iTmp);
-00114                         }
-00115                 }
-00116                 (void)tSkipBytes(pInFile, tPadding);
-00117         }
-00118         vASCII85EncodeByte(pOutFile, EOF);
-00119 } /* end of vDecode4bpp */
-00120 
-00121 /*
-00122  * vDecode8bpp - decode an uncompressed 8 bits per pixel image
-00123  */
-00124 static void
-00125 vDecode8bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00126 {
-00127         size_t  tPadding;
-00128         int     iX, iY, iByte;
-00129 
-00130         DBG_MSG("vDecode8bpp");
-00131 
-00132         fail(pInFile == NULL);
-00133         fail(pOutFile == NULL);
-00134         fail(pImg == NULL);
-00135         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
-00136 
-00137         DBG_DEC(pImg->iWidth);
-00138         DBG_DEC(pImg->iHeight);
-00139 
-00140         tPadding = (size_t)(ROUND4(pImg->iWidth) - pImg->iWidth);
-00141 
-00142         for (iY = 0; iY < pImg->iHeight; iY++) {
-00143                 for (iX = 0; iX < pImg->iWidth; iX++) {
-00144                         iByte = iNextByte(pInFile);
-00145                         if (iByte == EOF) {
-00146                                 vASCII85EncodeByte(pOutFile, EOF);
-00147                                 return;
-00148                         }
-00149                         vASCII85EncodeByte(pOutFile, iByte);
-00150                 }
-00151                 (void)tSkipBytes(pInFile, tPadding);
-00152         }
-00153         vASCII85EncodeByte(pOutFile, EOF);
-00154 } /* end of vDecode8bpp */
-00155 
-00156 /*
-00157  * vDecode24bpp - decode an uncompressed 24 bits per pixel image
-00158  */
-00159 static void
-00160 vDecode24bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00161 {
-00162         size_t  tPadding;
-00163         int     iX, iY, iBlue, iGreen, iRed, iTripleWidth;
-00164 
-00165         DBG_MSG("vDecode24bpp");
-00166 
-00167         fail(pInFile == NULL);
-00168         fail(pOutFile == NULL);
-00169         fail(pImg == NULL);
-00170         fail(!pImg->bColorImage);
-00171 
-00172         DBG_DEC(pImg->iWidth);
-00173         DBG_DEC(pImg->iHeight);
-00174 
-00175         iTripleWidth = pImg->iWidth * 3;
-00176         tPadding = (size_t)(ROUND4(iTripleWidth) - iTripleWidth);
-00177 
-00178         for (iY = 0; iY < pImg->iHeight; iY++) {
-00179                 for (iX = 0; iX < pImg->iWidth; iX++) {
-00180                         /* Change from BGR order to RGB order */
-00181                         iBlue = iNextByte(pInFile);
-00182                         if (iBlue == EOF) {
-00183                                 vASCII85EncodeByte(pOutFile, EOF);
-00184                                 return;
-00185                         }
-00186                         iGreen = iNextByte(pInFile);
-00187                         if (iGreen == EOF) {
-00188                                 vASCII85EncodeByte(pOutFile, EOF);
-00189                                 return;
-00190                         }
-00191                         iRed = iNextByte(pInFile);
-00192                         if (iRed == EOF) {
-00193                                 vASCII85EncodeByte(pOutFile, EOF);
-00194                                 return;
-00195                         }
-00196                         vASCII85EncodeByte(pOutFile, iRed);
-00197                         vASCII85EncodeByte(pOutFile, iGreen);
-00198                         vASCII85EncodeByte(pOutFile, iBlue);
-00199                 }
-00200                 (void)tSkipBytes(pInFile, tPadding);
-00201         }
-00202         vASCII85EncodeByte(pOutFile, EOF);
-00203 } /* end of vDecode24bpp */
-00204 
-00205 /*
-00206  * vDecodeRle4 - decode a RLE compressed 4 bits per pixel image
-00207  */
-00208 static void
-00209 vDecodeRle4(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00210 {
-00211         int     iX, iY, iByte, iTmp, iRunLength, iRun;
-00212         BOOL    bEOF, bEOL;
-00213 
-00214         DBG_MSG("vDecodeRle4");
-00215 
-00216         fail(pInFile == NULL);
-00217         fail(pOutFile == NULL);
-00218         fail(pImg == NULL);
-00219         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
-00220 
-00221         DBG_DEC(pImg->iWidth);
-00222         DBG_DEC(pImg->iHeight);
-00223 
-00224         bEOF = FALSE;
-00225 
-00226         for (iY =  0; iY < pImg->iHeight && !bEOF; iY++) {
-00227                 bEOL = FALSE;
-00228                 iX = 0;
-00229                 while (!bEOL) {
-00230                         iRunLength = iNextByte(pInFile);
-00231                         if (iRunLength == EOF) {
-00232                                 vASCII85EncodeByte(pOutFile, EOF);
-00233                                 return;
-00234                         }
-00235                         if (iRunLength != 0) {
-00236                                 /*
-00237                                  * Encoded packet:
-00238                                  * RunLength pixels, all the "same" value
-00239                                  */
-00240                                 iByte = iNextByte(pInFile);
-00241                                 if (iByte == EOF) {
-00242                                         vASCII85EncodeByte(pOutFile, EOF);
-00243                                         return;
-00244                                 }
-00245                                 for (iRun = 0; iRun < iRunLength; iRun++) {
-00246                                         if (odd(iRun)) {
-00247                                                 iTmp = iByte & 0x0f;
-00248                                         } else {
-00249                                                 iTmp = (iByte & 0xf0) / 16;
-00250                                         }
-00251                                         if (iX < pImg->iWidth) {
-00252                                                 vASCII85EncodeByte(pOutFile, iTmp);
-00253                                         }
-00254                                         iX++;
-00255                                 }
-00256                                 continue;
-00257                         }
-00258                         /* Literal or escape */
-00259                         iRunLength = iNextByte(pInFile);
-00260                         if (iRunLength == EOF) {
-00261                                 vASCII85EncodeByte(pOutFile, EOF);
-00262                                 return;
-00263                         }
-00264                         if (iRunLength == 0) {          /* End of line escape */
-00265                                 bEOL = TRUE;
-00266                         } else if (iRunLength == 1) {   /* End of file escape */
-00267                                 bEOF = TRUE;
-00268                                 bEOL = TRUE;
-00269                         } else if (iRunLength == 2) {   /* Delta escape */
-00270                                 DBG_MSG("RLE4: encountered delta escape");
-00271                                 bEOF = TRUE;
-00272                                 bEOL = TRUE;
-00273                         } else {                        /* Literal packet */
-00274                                 iByte = 0;
-00275                                 for (iRun = 0; iRun < iRunLength; iRun++) {
-00276                                         if (odd(iRun)) {
-00277                                                 iTmp = iByte & 0x0f;
-00278                                         } else {
-00279                                                 iByte = iNextByte(pInFile);
-00280                                                 if (iByte == EOF) {
-00281                                                         vASCII85EncodeByte(pOutFile, EOF);
-00282                                                         return;
-00283                                                 }
-00284                                                 iTmp = (iByte & 0xf0) / 16;
-00285                                         }
-00286                                         if (iX < pImg->iWidth) {
-00287                                                 vASCII85EncodeByte(pOutFile, iTmp);
-00288                                         }
-00289                                         iX++;
-00290                                 }
-00291                                 /* Padding if the number of bytes is odd */
-00292                                 if (odd((iRunLength + 1) / 2)) {
-00293                                         (void)tSkipBytes(pInFile, 1);
-00294                                 }
-00295                         }
-00296                 }
-00297                 DBG_DEC_C(iX != pImg->iWidth, iX);
-00298         }
-00299         vASCII85EncodeByte(pOutFile, EOF);
-00300 } /* end of vDecodeRle4 */
-00301 
-00302 /*
-00303  * vDecodeRle8 - decode a RLE compressed 8 bits per pixel image
-00304  */
-00305 static void
-00306 vDecodeRle8(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00307 {
-00308         int     iX, iY, iByte, iRunLength, iRun;
-00309         BOOL    bEOF, bEOL;
-00310 
-00311         DBG_MSG("vDecodeRle8");
-00312 
-00313         fail(pInFile == NULL);
-00314         fail(pOutFile == NULL);
-00315         fail(pImg == NULL);
-00316         fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
-00317 
-00318         DBG_DEC(pImg->iWidth);
-00319         DBG_DEC(pImg->iHeight);
-00320 
-00321         bEOF = FALSE;
-00322 
-00323         for (iY = 0; iY < pImg->iHeight && !bEOF; iY++) {
-00324                 bEOL = FALSE;
-00325                 iX = 0;
-00326                 while (!bEOL) {
-00327                         iRunLength = iNextByte(pInFile);
-00328                         if (iRunLength == EOF) {
-00329                                 vASCII85EncodeByte(pOutFile, EOF);
-00330                                 return;
-00331                         }
-00332                         if (iRunLength != 0) {
-00333                                 /*
-00334                                  * Encoded packet:
-00335                                  * RunLength pixels, all the same value
-00336                                  */
-00337                                 iByte = iNextByte(pInFile);
-00338                                 if (iByte == EOF) {
-00339                                         vASCII85EncodeByte(pOutFile, EOF);
-00340                                         return;
-00341                                 }
-00342                                 for (iRun = 0; iRun < iRunLength; iRun++) {
-00343                                         if (iX < pImg->iWidth) {
-00344                                                 vASCII85EncodeByte(pOutFile, iByte);
-00345                                         }
-00346                                         iX++;
-00347                                 }
-00348                                 continue;
-00349                         }
-00350                         /* Literal or escape */
-00351                         iRunLength = iNextByte(pInFile);
-00352                         if (iRunLength == EOF) {
-00353                                 vASCII85EncodeByte(pOutFile, EOF);
-00354                                 return;
-00355                         }
-00356                         if (iRunLength == 0) {          /* End of line escape */
-00357                                 bEOL = TRUE;
-00358                         } else if (iRunLength == 1) {   /* End of file escape */
-00359                                 bEOF = TRUE;
-00360                                 bEOL = TRUE;
-00361                         } else if (iRunLength == 2) {   /* Delta escape */
-00362                                 DBG_MSG("RLE8: encountered delta escape");
-00363                                 bEOF = TRUE;
-00364                                 bEOL = TRUE;
-00365                         } else {                        /* Literal packet */
-00366                                 for (iRun = 0; iRun < iRunLength; iRun++) {
-00367                                         iByte = iNextByte(pInFile);
-00368                                         if (iByte == EOF) {
-00369                                                 vASCII85EncodeByte(pOutFile, EOF);
-00370                                                 return;
-00371                                         }
-00372                                         if (iX < pImg->iWidth) {
-00373                                                 vASCII85EncodeByte(pOutFile, iByte);
-00374                                         }
-00375                                         iX++;
-00376                                 }
-00377                                 /* Padding if the number of bytes is odd */
-00378                                 if (odd(iRunLength)) {
-00379                                         (void)tSkipBytes(pInFile, 1);
-00380                                 }
-00381                         }
-00382                 }
-00383                 DBG_DEC_C(iX != pImg->iWidth, iX);
-00384         }
-00385         vASCII85EncodeByte(pOutFile, EOF);
-00386 } /* end of vDecodeRle8 */
-00387 
-00388 /*
-00389  * vDecodeDIB - decode a dib picture
-00390  */
-00391 static void
-00392 vDecodeDIB(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
-00393 {
-00394         size_t  tHeaderSize;
-00395 
-00396         fail(pInFile == NULL);
-00397         fail(pOutFile == NULL);
-00398         fail(pImg == NULL);
-00399 
-00400         /* Skip the bitmap info header */
-00401         tHeaderSize = (size_t)ulNextLong(pInFile);
-00402         (void)tSkipBytes(pInFile, tHeaderSize - 4);
-00403         /* Skip the colortable */
-00404         if (pImg->uiBitsPerComponent <= 8) {
-00405                 (void)tSkipBytes(pInFile,
-00406                         (size_t)(pImg->iColorsUsed *
-00407                          ((tHeaderSize > 12) ? 4 : 3)));
-00408         }
-00409 
-00410         switch (pImg->uiBitsPerComponent) {
-00411         case 1:
-00412                 fail(pImg->eCompression != compression_none);
-00413                 vDecode1bpp(pInFile, pOutFile, pImg);
-00414                 break;
-00415         case 4:
-00416                 fail(pImg->eCompression != compression_none &&
-00417                                 pImg->eCompression != compression_rle4);
-00418                 if (pImg->eCompression == compression_rle4) {
-00419                         vDecodeRle4(pInFile, pOutFile, pImg);
-00420                 } else {
-00421                         vDecode4bpp(pInFile, pOutFile, pImg);
-00422                 }
-00423                 break;
-00424         case 8:
-00425                 fail(pImg->eCompression != compression_none &&
-00426                                 pImg->eCompression != compression_rle8);
-00427                 if (pImg->eCompression == compression_rle8) {
-00428                         vDecodeRle8(pInFile, pOutFile, pImg);
-00429                 } else {
-00430                         vDecode8bpp(pInFile, pOutFile, pImg);
-00431                 }
-00432                 break;
-00433         case 24:
-00434                 fail(pImg->eCompression != compression_none);
-00435                 vDecode24bpp(pInFile, pOutFile, pImg);
-00436                 break;
-00437         default:
-00438                 DBG_DEC(pImg->uiBitsPerComponent);
-00439                 break;
-00440         }
-00441 } /* end of vDecodeDIB */
-00442 
-00443 #if defined(DEBUG)
-00444 /*
-00445  * vCopy2File
-00446  */
-00447 static void
-00448 vCopy2File(FILE *pInFile, ULONG ulFileOffset, size_t tPictureLen)
-00449 {
-00450         static int      iPicCounter = 0;
-00451         FILE    *pOutFile;
-00452         size_t  tIndex;
-00453         int     iTmp;
-00454         char    szFilename[30];
-00455 
-00456         if (!bSetDataOffset(pInFile, ulFileOffset)) {
-00457                 return;
-00458         }
-00459 
-00460         sprintf(szFilename, "/tmp/pic/pic%04d.bmp", ++iPicCounter);
-00461         pOutFile = fopen(szFilename, "wb");
-00462         if (pOutFile == NULL) {
-00463                 return;
-00464         }
-00465         /* Turn a dib into a bmp by adding a fake 14 byte header */
-00466         (void)putc('B', pOutFile);
-00467         (void)putc('M', pOutFile);
-00468         for (iTmp = 0; iTmp < 12; iTmp++) {
-00469                 if (putc(0, pOutFile) == EOF) {
-00470                         break;
-00471                 }
-00472         }
-00473         for (tIndex = 0; tIndex < tPictureLen; tIndex++) {
-00474                 iTmp = iNextByte(pInFile);
-00475                 if (putc(iTmp, pOutFile) == EOF) {
-00476                         break;
-00477                 }
-00478         }
-00479         (void)fclose(pOutFile);
-00480 } /* end of vCopy2File */
-00481 #endif /* DEBUG */
-00482 
-00483 /*
-00484  * bTranslateDIB - translate a DIB picture
-00485  *
-00486  * This function translates a picture from dib to eps
-00487  *
-00488  * return TRUE when sucessful, otherwise FALSE
-00489  */
-00490 BOOL
-00491 bTranslateDIB(diagram_type *pDiag, FILE *pInFile,
-00492                 ULONG ulFileOffset, const imagedata_type *pImg)
-00493 {
-00494 #if defined(DEBUG)
-00495         fail(pImg->tPosition > pImg->tLength);
-00496         vCopy2File(pInFile, ulFileOffset, pImg->tLength - pImg->tPosition);
-00497 #endif /* DEBUG */
-00498 
-00499         /* Seek to start position of DIB data */
-00500         if (!bSetDataOffset(pInFile, ulFileOffset)) {
-00501                 return FALSE;
-00502         }
-00503 
-00504         vImagePrologue(pDiag, pImg);
-00505         vDecodeDIB(pInFile, pDiag->pOutFile, pImg);
-00506         vImageEpilogue(pDiag);
-00507 
-00508         return TRUE;
-00509 } /* end of bTranslateDIB */
-