ref: ad26dc48a6dc05da02f96e5f1e7b82de58ff5b2c
dir: /sys/src/cmd/aux/antiword/dib2eps.c/
/*
* dib2eps.c
* Copyright (C) 2000-2003 A.J. van Os; Released under GPL
*
* Description:
* Functions to translate dib pictures into eps
*
*================================================================
* This part of the software is based on:
* The Windows Bitmap Decoder Class part of paintlib
* Paintlib is copyright (c) 1996-2000 Ulrich von Zadow
*================================================================
* The credit should go to him, but all the bugs are mine.
*/
#include <stdio.h>
#include "antiword.h"
/*
* vDecode1bpp - decode an uncompressed 1 bit per pixel image
*/
static void
vDecode1bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
size_t tPadding;
int iX, iY, iN, iByte, iTmp, iEighthWidth, iUse;
DBG_MSG("vDecode1bpp");
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 2);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
iEighthWidth = (pImg->iWidth + 7) / 8;
tPadding = (size_t)(ROUND4(iEighthWidth) - iEighthWidth);
for (iY = 0; iY < pImg->iHeight; iY++) {
for (iX = 0; iX < iEighthWidth; iX++) {
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iX == iEighthWidth - 1 && pImg->iWidth % 8 != 0) {
iUse = pImg->iWidth % 8;
} else {
iUse = 8;
}
for (iN = 0; iN < iUse; iN++) {
switch (iN) {
case 0: iTmp = (iByte & 0x80) / 128; break;
case 1: iTmp = (iByte & 0x40) / 64; break;
case 2: iTmp = (iByte & 0x20) / 32; break;
case 3: iTmp = (iByte & 0x10) / 16; break;
case 4: iTmp = (iByte & 0x08) / 8; break;
case 5: iTmp = (iByte & 0x04) / 4; break;
case 6: iTmp = (iByte & 0x02) / 2; break;
case 7: iTmp = (iByte & 0x01); break;
default: iTmp = 0; break;
}
vASCII85EncodeByte(pOutFile, iTmp);
}
}
(void)tSkipBytes(pInFile, tPadding);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecode1bpp */
/*
* vDecode4bpp - decode an uncompressed 4 bits per pixel image
*/
static void
vDecode4bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
size_t tPadding;
int iX, iY, iN, iByte, iTmp, iHalfWidth, iUse;
DBG_MSG("vDecode4bpp");
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
iHalfWidth = (pImg->iWidth + 1) / 2;
tPadding = (size_t)(ROUND4(iHalfWidth) - iHalfWidth);
for (iY = 0; iY < pImg->iHeight; iY++) {
for (iX = 0; iX < iHalfWidth; iX++) {
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iX == iHalfWidth - 1 && odd(pImg->iWidth)) {
iUse = 1;
} else {
iUse = 2;
}
for (iN = 0; iN < iUse; iN++) {
if (odd(iN)) {
iTmp = iByte & 0x0f;
} else {
iTmp = (iByte & 0xf0) / 16;
}
vASCII85EncodeByte(pOutFile, iTmp);
}
}
(void)tSkipBytes(pInFile, tPadding);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecode4bpp */
/*
* vDecode8bpp - decode an uncompressed 8 bits per pixel image
*/
static void
vDecode8bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
size_t tPadding;
int iX, iY, iByte;
DBG_MSG("vDecode8bpp");
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
tPadding = (size_t)(ROUND4(pImg->iWidth) - pImg->iWidth);
for (iY = 0; iY < pImg->iHeight; iY++) {
for (iX = 0; iX < pImg->iWidth; iX++) {
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
vASCII85EncodeByte(pOutFile, iByte);
}
(void)tSkipBytes(pInFile, tPadding);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecode8bpp */
/*
* vDecode24bpp - decode an uncompressed 24 bits per pixel image
*/
static void
vDecode24bpp(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
size_t tPadding;
int iX, iY, iBlue, iGreen, iRed, iTripleWidth;
DBG_MSG("vDecode24bpp");
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(!pImg->bColorImage);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
iTripleWidth = pImg->iWidth * 3;
tPadding = (size_t)(ROUND4(iTripleWidth) - iTripleWidth);
for (iY = 0; iY < pImg->iHeight; iY++) {
for (iX = 0; iX < pImg->iWidth; iX++) {
/* Change from BGR order to RGB order */
iBlue = iNextByte(pInFile);
if (iBlue == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
iGreen = iNextByte(pInFile);
if (iGreen == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
iRed = iNextByte(pInFile);
if (iRed == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
vASCII85EncodeByte(pOutFile, iRed);
vASCII85EncodeByte(pOutFile, iGreen);
vASCII85EncodeByte(pOutFile, iBlue);
}
(void)tSkipBytes(pInFile, tPadding);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecode24bpp */
/*
* vDecodeRle4 - decode a RLE compressed 4 bits per pixel image
*/
static void
vDecodeRle4(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
int iX, iY, iByte, iTmp, iRunLength, iRun;
BOOL bEOF, bEOL;
DBG_MSG("vDecodeRle4");
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 16);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
bEOF = FALSE;
for (iY = 0; iY < pImg->iHeight && !bEOF; iY++) {
bEOL = FALSE;
iX = 0;
while (!bEOL) {
iRunLength = iNextByte(pInFile);
if (iRunLength == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iRunLength != 0) {
/*
* Encoded packet:
* RunLength pixels, all the "same" value
*/
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
for (iRun = 0; iRun < iRunLength; iRun++) {
if (odd(iRun)) {
iTmp = iByte & 0x0f;
} else {
iTmp = (iByte & 0xf0) / 16;
}
if (iX < pImg->iWidth) {
vASCII85EncodeByte(pOutFile, iTmp);
}
iX++;
}
continue;
}
/* Literal or escape */
iRunLength = iNextByte(pInFile);
if (iRunLength == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iRunLength == 0) { /* End of line escape */
bEOL = TRUE;
} else if (iRunLength == 1) { /* End of file escape */
bEOF = TRUE;
bEOL = TRUE;
} else if (iRunLength == 2) { /* Delta escape */
DBG_MSG("RLE4: encountered delta escape");
bEOF = TRUE;
bEOL = TRUE;
} else { /* Literal packet */
iByte = 0;
for (iRun = 0; iRun < iRunLength; iRun++) {
if (odd(iRun)) {
iTmp = iByte & 0x0f;
} else {
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
iTmp = (iByte & 0xf0) / 16;
}
if (iX < pImg->iWidth) {
vASCII85EncodeByte(pOutFile, iTmp);
}
iX++;
}
/* Padding if the number of bytes is odd */
if (odd((iRunLength + 1) / 2)) {
(void)tSkipBytes(pInFile, 1);
}
}
}
DBG_DEC_C(iX != pImg->iWidth, iX);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecodeRle4 */
/*
* vDecodeRle8 - decode a RLE compressed 8 bits per pixel image
*/
static void
vDecodeRle8(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
int iX, iY, iByte, iRunLength, iRun;
BOOL bEOF, bEOL;
DBG_MSG("vDecodeRle8");
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
fail(pImg->iColorsUsed < 1 || pImg->iColorsUsed > 256);
DBG_DEC(pImg->iWidth);
DBG_DEC(pImg->iHeight);
bEOF = FALSE;
for (iY = 0; iY < pImg->iHeight && !bEOF; iY++) {
bEOL = FALSE;
iX = 0;
while (!bEOL) {
iRunLength = iNextByte(pInFile);
if (iRunLength == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iRunLength != 0) {
/*
* Encoded packet:
* RunLength pixels, all the same value
*/
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
for (iRun = 0; iRun < iRunLength; iRun++) {
if (iX < pImg->iWidth) {
vASCII85EncodeByte(pOutFile, iByte);
}
iX++;
}
continue;
}
/* Literal or escape */
iRunLength = iNextByte(pInFile);
if (iRunLength == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iRunLength == 0) { /* End of line escape */
bEOL = TRUE;
} else if (iRunLength == 1) { /* End of file escape */
bEOF = TRUE;
bEOL = TRUE;
} else if (iRunLength == 2) { /* Delta escape */
DBG_MSG("RLE8: encountered delta escape");
bEOF = TRUE;
bEOL = TRUE;
} else { /* Literal packet */
for (iRun = 0; iRun < iRunLength; iRun++) {
iByte = iNextByte(pInFile);
if (iByte == EOF) {
vASCII85EncodeByte(pOutFile, EOF);
return;
}
if (iX < pImg->iWidth) {
vASCII85EncodeByte(pOutFile, iByte);
}
iX++;
}
/* Padding if the number of bytes is odd */
if (odd(iRunLength)) {
(void)tSkipBytes(pInFile, 1);
}
}
}
DBG_DEC_C(iX != pImg->iWidth, iX);
}
vASCII85EncodeByte(pOutFile, EOF);
} /* end of vDecodeRle8 */
/*
* vDecodeDIB - decode a dib picture
*/
static void
vDecodeDIB(FILE *pInFile, FILE *pOutFile, const imagedata_type *pImg)
{
size_t tHeaderSize;
fail(pInFile == NULL);
fail(pOutFile == NULL);
fail(pImg == NULL);
/* Skip the bitmap info header */
tHeaderSize = (size_t)ulNextLong(pInFile);
(void)tSkipBytes(pInFile, tHeaderSize - 4);
/* Skip the colortable */
if (pImg->uiBitsPerComponent <= 8) {
(void)tSkipBytes(pInFile,
(size_t)(pImg->iColorsUsed *
((tHeaderSize > 12) ? 4 : 3)));
}
switch (pImg->uiBitsPerComponent) {
case 1:
fail(pImg->eCompression != compression_none);
vDecode1bpp(pInFile, pOutFile, pImg);
break;
case 4:
fail(pImg->eCompression != compression_none &&
pImg->eCompression != compression_rle4);
if (pImg->eCompression == compression_rle4) {
vDecodeRle4(pInFile, pOutFile, pImg);
} else {
vDecode4bpp(pInFile, pOutFile, pImg);
}
break;
case 8:
fail(pImg->eCompression != compression_none &&
pImg->eCompression != compression_rle8);
if (pImg->eCompression == compression_rle8) {
vDecodeRle8(pInFile, pOutFile, pImg);
} else {
vDecode8bpp(pInFile, pOutFile, pImg);
}
break;
case 24:
fail(pImg->eCompression != compression_none);
vDecode24bpp(pInFile, pOutFile, pImg);
break;
default:
DBG_DEC(pImg->uiBitsPerComponent);
break;
}
} /* end of vDecodeDIB */
#if defined(DEBUG)
/*
* vCopy2File
*/
static void
vCopy2File(FILE *pInFile, ULONG ulFileOffset, size_t tPictureLen)
{
static int iPicCounter = 0;
FILE *pOutFile;
size_t tIndex;
int iTmp;
char szFilename[30];
if (!bSetDataOffset(pInFile, ulFileOffset)) {
return;
}
sprintf(szFilename, "/tmp/pic/pic%04d.bmp", ++iPicCounter);
pOutFile = fopen(szFilename, "wb");
if (pOutFile == NULL) {
return;
}
/* Turn a dib into a bmp by adding a fake 14 byte header */
(void)putc('B', pOutFile);
(void)putc('M', pOutFile);
for (iTmp = 0; iTmp < 12; iTmp++) {
if (putc(0, pOutFile) == EOF) {
break;
}
}
for (tIndex = 0; tIndex < tPictureLen; tIndex++) {
iTmp = iNextByte(pInFile);
if (putc(iTmp, pOutFile) == EOF) {
break;
}
}
(void)fclose(pOutFile);
} /* end of vCopy2File */
#endif /* DEBUG */
/*
* bTranslateDIB - translate a DIB picture
*
* This function translates a picture from dib to eps
*
* return TRUE when sucessful, otherwise FALSE
*/
BOOL
bTranslateDIB(diagram_type *pDiag, FILE *pInFile,
ULONG ulFileOffset, const imagedata_type *pImg)
{
#if defined(DEBUG)
fail(pImg->tPosition > pImg->tLength);
vCopy2File(pInFile, ulFileOffset, pImg->tLength - pImg->tPosition);
#endif /* DEBUG */
/* Seek to start position of DIB data */
if (!bSetDataOffset(pInFile, ulFileOffset)) {
return FALSE;
}
vImagePrologue(pDiag, pImg);
vDecodeDIB(pInFile, pDiag->pOutFile, pImg);
vImageEpilogue(pDiag);
return TRUE;
} /* end of bTranslateDIB */