examples/PIPS/antiword/src/imgexam.c

/*
 * imgexam.c
 * Copyright (C) 2000-2004 A.J. van Os; Released under GNU GPL
 *
 * Description:
 * Functions to examine image headers
 *
 *================================================================
 * Part of this software is based on:
 * jpeg2ps - convert JPEG compressed images to PostScript Level 2
 * Copyright (C) 1994-99 Thomas Merz ([email protected])
 *================================================================
 * The credit should go to him, but all the bugs are mine.
 */

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "antiword.h"

/* BMP compression types */
#define BI_RGB          0
#define BI_RLE8         1
#define BI_RLE4         2

/* PNG colortype bits */
#define PNG_CB_PALETTE          0x01
#define PNG_CB_COLOR            0x02
#define PNG_CB_ALPHA            0x04

/* Instance signature */
#define MSOBI_WMF       0x0216
#define MSOBI_EMF       0x03d4
#define MSOBI_PICT      0x0542
#define MSOBI_PNG       0x06e0
#define MSOBI_JPEG      0x046a
#define MSOBI_DIB       0x07a8

/* The following enum is stolen from the IJG JPEG library */
typedef enum {          /* JPEG marker codes                    */
        M_SOF0  = 0xc0, /* baseline DCT                         */
        M_SOF1  = 0xc1, /* extended sequential DCT              */
        M_SOF2  = 0xc2, /* progressive DCT                      */
        M_SOF3  = 0xc3, /* lossless (sequential)                */

        M_SOF5  = 0xc5, /* differential sequential DCT          */
        M_SOF6  = 0xc6, /* differential progressive DCT         */
        M_SOF7  = 0xc7, /* differential lossless                */

        M_JPG   = 0xc8, /* JPEG extensions                      */
        M_SOF9  = 0xc9, /* extended sequential DCT              */
        M_SOF10 = 0xca, /* progressive DCT                      */
        M_SOF11 = 0xcb, /* lossless (sequential)                */

        M_SOF13 = 0xcd, /* differential sequential DCT          */
        M_SOF14 = 0xce, /* differential progressive DCT         */
        M_SOF15 = 0xcf, /* differential lossless                */

        M_DHT   = 0xc4, /* define Huffman tables                */

        M_DAC   = 0xcc, /* define arithmetic conditioning table */

        M_RST0  = 0xd0, /* restart                              */
        M_RST1  = 0xd1, /* restart                              */
        M_RST2  = 0xd2, /* restart                              */
        M_RST3  = 0xd3, /* restart                              */
        M_RST4  = 0xd4, /* restart                              */
        M_RST5  = 0xd5, /* restart                              */
        M_RST6  = 0xd6, /* restart                              */
        M_RST7  = 0xd7, /* restart                              */

        M_SOI   = 0xd8, /* start of image                       */
        M_EOI   = 0xd9, /* end of image                         */
        M_SOS   = 0xda, /* start of scan                        */
        M_DQT   = 0xdb, /* define quantization tables           */
        M_DNL   = 0xdc, /* define number of lines               */
        M_DRI   = 0xdd, /* define restart interval              */
        M_DHP   = 0xde, /* define hierarchical progression      */
        M_EXP   = 0xdf, /* expand reference image(s)            */

        M_APP0  = 0xe0, /* application marker, used for JFIF    */
        M_APP1  = 0xe1, /* application marker                   */
        M_APP2  = 0xe2, /* application marker                   */
        M_APP3  = 0xe3, /* application marker                   */
        M_APP4  = 0xe4, /* application marker                   */
        M_APP5  = 0xe5, /* application marker                   */
        M_APP6  = 0xe6, /* application marker                   */
        M_APP7  = 0xe7, /* application marker                   */
        M_APP8  = 0xe8, /* application marker                   */
        M_APP9  = 0xe9, /* application marker                   */
        M_APP10 = 0xea, /* application marker                   */
        M_APP11 = 0xeb, /* application marker                   */
        M_APP12 = 0xec, /* application marker                   */
        M_APP13 = 0xed, /* application marker                   */
        M_APP14 = 0xee, /* application marker, used by Adobe    */
        M_APP15 = 0xef, /* application marker                   */

        M_JPG0  = 0xf0, /* reserved for JPEG extensions         */
        M_JPG13 = 0xfd, /* reserved for JPEG extensions         */
        M_COM   = 0xfe, /* comment                              */

        M_TEM   = 0x01  /* temporary use                        */
} JPEG_MARKER;


/*
 * bFillPaletteDIB - fill the palette part of the imagesdata
 *
 * returns TRUE if the images must be a color image, otherwise FALSE;
 */
static BOOL
bFillPaletteDIB(FILE *pFile, imagedata_type *pImg, BOOL bNewFormat)
{
        int     iIndex;
        BOOL    bIsColorPalette;

        fail(pFile == NULL);
        fail(pImg == NULL);

        if (pImg->uiBitsPerComponent > 8) {
                /* No palette, image uses more than 256 colors */
                return TRUE;
        }

        if (pImg->iColorsUsed <= 0) {
                /* Not specified, so compute the number of colors used */
                pImg->iColorsUsed = 1 << pImg->uiBitsPerComponent;
        }

        fail(pImg->iColorsUsed > 256);
        if (pImg->iColorsUsed > 256) {
                pImg->iColorsUsed = 256;
        }

        bIsColorPalette = FALSE;
        for (iIndex = 0; iIndex < pImg->iColorsUsed; iIndex++) {
                /* From BGR order to RGB order */
                pImg->aucPalette[iIndex][2] = (UCHAR)iNextByte(pFile);
                pImg->aucPalette[iIndex][1] = (UCHAR)iNextByte(pFile);
                pImg->aucPalette[iIndex][0] = (UCHAR)iNextByte(pFile);
                if (bNewFormat) {
                        (void)iNextByte(pFile);
                }
                NO_DBG_PRINT_BLOCK(pImg->aucPalette[iIndex], 3);
                if (pImg->aucPalette[iIndex][0] !=
                     pImg->aucPalette[iIndex][1] ||
                    pImg->aucPalette[iIndex][1] !=
                     pImg->aucPalette[iIndex][2]) {
                        bIsColorPalette = TRUE;
                }
        }

        return bIsColorPalette;
} /* end of bFillPaletteDIB */

/*
 * bExamineDIB - Examine a DIB header
 *
 * return TRUE if successful, otherwise FALSE
 */
static BOOL
bExamineDIB(FILE *pFile, imagedata_type *pImg)
{
        size_t  tHeaderSize;
        int     iPlanes, iCompression;

        tHeaderSize = (size_t)ulNextLong(pFile);
        switch (tHeaderSize) {
        case 12:
                pImg->iWidth = (int)usNextWord(pFile);
                pImg->iHeight = (int)usNextWord(pFile);
                iPlanes = (int)usNextWord(pFile);
                pImg->uiBitsPerComponent = (UINT)usNextWord(pFile);
                iCompression = BI_RGB;
                pImg->iColorsUsed = 0;
                break;
        case 40:
        case 64:
                pImg->iWidth = (int)ulNextLong(pFile);
                pImg->iHeight = (int)ulNextLong(pFile);
                iPlanes = (int)usNextWord(pFile);
                pImg->uiBitsPerComponent = (UINT)usNextWord(pFile);
                iCompression = (int)ulNextLong(pFile);
                (void)tSkipBytes(pFile, 12);
                pImg->iColorsUsed = (int)ulNextLong(pFile);
                (void)tSkipBytes(pFile, tHeaderSize - 36);
                break;
        default:
                DBG_DEC(tHeaderSize);
                return FALSE;
        }
        DBG_DEC(pImg->iWidth);
        DBG_DEC(pImg->iHeight);
        DBG_DEC(pImg->uiBitsPerComponent);
        DBG_DEC(iCompression);
        DBG_DEC(pImg->iColorsUsed);

        /* Do some sanity checks with the parameters */
        if (iPlanes != 1) {
                DBG_DEC(iPlanes);
                return FALSE;
        }
        if (pImg->iWidth <= 0 || pImg->iHeight <= 0) {
                DBG_DEC(pImg->iWidth);
                DBG_DEC(pImg->iHeight);
                return FALSE;
        }
        if (pImg->uiBitsPerComponent != 1 && pImg->uiBitsPerComponent != 4 &&
            pImg->uiBitsPerComponent != 8 && pImg->uiBitsPerComponent != 24) {
                DBG_DEC(pImg->uiBitsPerComponent);
                return FALSE;
        }
        if (iCompression != BI_RGB &&
            (pImg->uiBitsPerComponent == 1 || pImg->uiBitsPerComponent == 24)) {
                return FALSE;
        }
        if (iCompression == BI_RLE8 && pImg->uiBitsPerComponent == 4) {
                return FALSE;
        }
        if (iCompression == BI_RLE4 && pImg->uiBitsPerComponent == 8) {
                return FALSE;
        }

        switch (iCompression) {
        case BI_RGB:
                pImg->eCompression = compression_none;
                break;
        case BI_RLE4:
                pImg->eCompression = compression_rle4;
                break;
        case BI_RLE8:
                pImg->eCompression = compression_rle8;
                break;
        default:
                DBG_DEC(iCompression);
                return FALSE;
        }

        pImg->bColorImage = bFillPaletteDIB(pFile, pImg, tHeaderSize > 12);

        if (pImg->uiBitsPerComponent <= 8) {
                pImg->iComponents = 1;
        } else {
                pImg->iComponents = (int)(pImg->uiBitsPerComponent / 8);
        }

        return TRUE;
} /* end of bExamineDIB */

/*
 * iNextMarker - read the next JPEG marker
 */
static int
iNextMarker(FILE *pFile)
{
        int     iMarker;

        do {
                do {
                        iMarker = iNextByte(pFile);
                } while (iMarker != 0xff && iMarker != EOF);
                if (iMarker == EOF) {
                        return EOF;
                }
                do {
                        iMarker = iNextByte(pFile);
                } while (iMarker == 0xff);
        } while (iMarker == 0x00);                      /* repeat if ff/00 */

        return iMarker;
} /* end of iNextMarker */

/*
 * bExamineJPEG - Examine a JPEG header
 *
 * return TRUE if successful, otherwise FALSE
 */
static BOOL
bExamineJPEG(FILE *pFile, imagedata_type *pImg)
{
        size_t  tLength;
        int     iMarker, iIndex;
        char    appstring[10];
        BOOL    bSOFDone;

        tLength = 0;
        bSOFDone = FALSE;

        /* process JPEG markers */
        while (!bSOFDone && (iMarker = iNextMarker(pFile)) != (int)M_EOI) {
                switch (iMarker) {
                case EOF:
                        DBG_MSG("Error: unexpected end of JPEG file");
                        return FALSE;
        /* The following are not officially supported in PostScript level 2 */
                case M_SOF2:
                case M_SOF3:
                case M_SOF5:
                case M_SOF6:
                case M_SOF7:
                case M_SOF9:
                case M_SOF10:
                case M_SOF11:
                case M_SOF13:
                case M_SOF14:
                case M_SOF15:
                        DBG_HEX(iMarker);
                        return FALSE;
                case M_SOF0:
                case M_SOF1:
                        tLength = (size_t)usNextWordBE(pFile);
                        pImg->uiBitsPerComponent = (UINT)iNextByte(pFile);
                        pImg->iHeight = (int)usNextWordBE(pFile);
                        pImg->iWidth = (int)usNextWordBE(pFile);
                        pImg->iComponents = iNextByte(pFile);
                        bSOFDone = TRUE;
                        break;
                case M_APP14:
                /*
                 * Check for Adobe application marker. It is known (per Adobe's
                 * TN5116) to contain the string "Adobe" at the start of the
                 * APP14 marker.
                 */
                        tLength = (size_t)usNextWordBE(pFile);
                        if (tLength < 12) {
                                (void)tSkipBytes(pFile, tLength - 2);
                        } else {
                                for (iIndex = 0; iIndex < 5; iIndex++) {
                                        appstring[iIndex] =
                                                        (char)iNextByte(pFile);
                                }
                                appstring[5] = '\0';
                                if (STREQ(appstring, "Adobe")) {
                                        pImg->bAdobe = TRUE;
                                }
                                (void)tSkipBytes(pFile, tLength - 7);
                        }
                        break;
                case M_SOI:             /* ignore markers without parameters */
                case M_EOI:
                case M_TEM:
                case M_RST0:
                case M_RST1:
                case M_RST2:
                case M_RST3:
                case M_RST4:
                case M_RST5:
                case M_RST6:
                case M_RST7:
                        break;
                default:                /* skip variable length markers */
                        tLength = (size_t)usNextWordBE(pFile);
                        (void)tSkipBytes(pFile, tLength - 2);
                        break;
                }
        }

        DBG_DEC(pImg->iWidth);
        DBG_DEC(pImg->iHeight);
        DBG_DEC(pImg->uiBitsPerComponent);
        DBG_DEC(pImg->iComponents);

        /* Do some sanity checks with the parameters */
        if (pImg->iHeight <= 0 ||
            pImg->iWidth <= 0 ||
            pImg->iComponents <= 0) {
                DBG_DEC(pImg->iHeight);
                DBG_DEC(pImg->iWidth);
                DBG_DEC(pImg->iComponents);
                return FALSE;
        }

        /* Some broken JPEG files have this but they print anyway... */
        if (pImg->iComponents * 3 + 8 != (int)tLength) {
                DBG_MSG("Warning: SOF marker has incorrect length - ignored");
        }

        if (pImg->uiBitsPerComponent != 8) {
                DBG_DEC(pImg->uiBitsPerComponent);
                DBG_MSG("Not supported in PostScript level 2");
                return FALSE;
        }

        if (pImg->iComponents != 1 &&
            pImg->iComponents != 3 &&
            pImg->iComponents != 4) {
                DBG_DEC(pImg->iComponents);
                return FALSE;
        }

        pImg->bColorImage = pImg->iComponents >= 3;
        pImg->iColorsUsed = 0;
        pImg->eCompression = compression_jpeg;

        return TRUE;
} /* end of bExamineJPEG */

/*
 * bFillPalettePNG - fill the palette part of the imagesdata
 *
 * returns TRUE if sucessful, otherwise FALSE;
 */
static BOOL
bFillPalettePNG(FILE *pFile, imagedata_type *pImg, size_t tLength)
{
        int     iIndex, iEntries;

        fail(pFile == NULL);
        fail(pImg == NULL);

        if (pImg->uiBitsPerComponent > 8) {
                /* No palette, image uses more than 256 colors */
                return TRUE;
        }

        if (!pImg->bColorImage) {
                /* Only color images can have a palette */
                return FALSE;
        }

        if (tLength % 3 != 0) {
                /* Each palette entry takes three bytes */
                DBG_DEC(tLength);
                return FALSE;
        }

        iEntries = (int)(tLength / 3);
        DBG_DEC(iEntries);
        pImg->iColorsUsed = 1 << pImg->uiBitsPerComponent;
        DBG_DEC(pImg->iColorsUsed);

        if (iEntries > 256) {
                DBG_DEC(iEntries);
                return FALSE;
        }

        for (iIndex = 0; iIndex < iEntries; iIndex++) {
                pImg->aucPalette[iIndex][0] = (UCHAR)iNextByte(pFile);
                pImg->aucPalette[iIndex][1] = (UCHAR)iNextByte(pFile);
                pImg->aucPalette[iIndex][2] = (UCHAR)iNextByte(pFile);
                NO_DBG_PRINT_BLOCK(pImg->aucPalette[iIndex], 3);
        }
        for (;iIndex < pImg->iColorsUsed; iIndex++) {
                pImg->aucPalette[iIndex][0] = 0;
                pImg->aucPalette[iIndex][1] = 0;
                pImg->aucPalette[iIndex][2] = 0;
        }

        return TRUE;
} /* end of bFillPalettePNG */

/*
 * bExaminePNG - Examine a PNG header
 *
 * return TRUE if successful, otherwise FALSE
 */
static BOOL
bExaminePNG(FILE *pFile, imagedata_type *pImg)
{
        size_t          tLength;
        ULONG           ulLong1, ulLong2, ulName;
        int             iIndex, iTmp;
        int             iCompressionMethod, iFilterMethod, iInterlaceMethod;
        int             iColor, iIncrement;
        BOOL            bHasPalette, bHasAlpha;
        UCHAR   aucBuf[4];

        /* Check signature */
        ulLong1 = ulNextLongBE(pFile);
        ulLong2 = ulNextLongBE(pFile);
        if (ulLong1 != 0x89504e47UL || ulLong2 != 0x0d0a1a0aUL) {
                DBG_HEX(ulLong1);
                DBG_HEX(ulLong2);
                return FALSE;
        }

        ulName = 0x00;
        bHasPalette = FALSE;

        /* Examine chunks */
        while (ulName != PNG_CN_IEND) {
                tLength = (size_t)ulNextLongBE(pFile);
                ulName = 0x00;
                for (iIndex = 0; iIndex < (int)elementsof(aucBuf); iIndex++) {
                        aucBuf[iIndex] = (UCHAR)iNextByte(pFile);
                        if (!isalpha(aucBuf[iIndex])) {
                                DBG_HEX(aucBuf[iIndex]);
                                return FALSE;
                        }
                        ulName <<= 8;
                        ulName |= aucBuf[iIndex];
                }

                switch (ulName) {
                case PNG_CN_IHDR:
                        /* Header chunck */
                        if (tLength < 13) {
                                DBG_DEC(tLength);
                                return FALSE;
                        }
                        pImg->iWidth = (int)ulNextLongBE(pFile);
                        pImg->iHeight = (int)ulNextLongBE(pFile);
                        pImg->uiBitsPerComponent = (UINT)iNextByte(pFile);
                        iTmp = iNextByte(pFile);
                        NO_DBG_HEX(iTmp);
                        pImg->bColorImage = (iTmp & PNG_CB_COLOR) != 0;
                        bHasPalette = (iTmp & PNG_CB_PALETTE) != 0;
                        bHasAlpha = (iTmp & PNG_CB_ALPHA) != 0;
                        if (bHasPalette && pImg->uiBitsPerComponent > 8) {
                                /* This should not happen */
                                return FALSE;
                        }
                        pImg->iComponents =
                                (bHasPalette || !pImg->bColorImage) ? 1 : 3;
                        if (bHasAlpha) {
                                pImg->iComponents++;
                        }
                        iCompressionMethod = iNextByte(pFile);
                        if (iCompressionMethod != 0) {
                                DBG_DEC(iCompressionMethod);
                                return FALSE;
                        }
                        iFilterMethod = iNextByte(pFile);
                        if (iFilterMethod != 0) {
                                DBG_DEC(iFilterMethod);
                                return FALSE;
                        }
                        iInterlaceMethod = iNextByte(pFile);
                        if (iInterlaceMethod != 0) {
                                DBG_DEC(iInterlaceMethod);
                                return FALSE;
                        }
                        pImg->iColorsUsed = 0;
                        (void)tSkipBytes(pFile, tLength - 13 + 4);
                        break;
                case PNG_CN_PLTE:
                        if (!bHasPalette) {
                                return FALSE;
                        }
                        if (!bFillPalettePNG(pFile, pImg, tLength)) {
                                return FALSE;
                        }
                        (void)tSkipBytes(pFile, 4);
                        break;
                default:
                        (void)tSkipBytes(pFile, tLength + 4);
                        break;
                }
        }

        DBG_DEC(pImg->iWidth);
        DBG_DEC(pImg->iHeight);
        DBG_DEC(pImg->uiBitsPerComponent);
        DBG_DEC(pImg->iColorsUsed);
        DBG_DEC(pImg->iComponents);

        /* Do some sanity checks with the parameters */
        if (pImg->iWidth <= 0 || pImg->iHeight <= 0) {
                return FALSE;
        }

        if (pImg->uiBitsPerComponent != 1 && pImg->uiBitsPerComponent != 2 &&
            pImg->uiBitsPerComponent != 4 && pImg->uiBitsPerComponent != 8 &&
            pImg->uiBitsPerComponent != 16) {
                DBG_DEC(pImg->uiBitsPerComponent);
                return  FALSE;
        }

        if (pImg->iComponents != 1 && pImg->iComponents != 3) {
                /* Not supported */
                DBG_DEC(pImg->iComponents);
                return FALSE;
        }

        if (pImg->uiBitsPerComponent > 8) {
                /* Not supported */
                DBG_DEC(pImg->uiBitsPerComponent);
                return FALSE;
        }

        if (pImg->iColorsUsed == 0 &&
            pImg->iComponents == 1 &&
            pImg->uiBitsPerComponent <= 4) {
                /*
                 * No palette is supplied, but PostScript needs one in these
                 * cases, so we add a default palette here
                 */
                pImg->iColorsUsed = 1 << pImg->uiBitsPerComponent;
                iIncrement = 0xff / (pImg->iColorsUsed - 1);
                for (iIndex = 0, iColor = 0x00;
                     iIndex < pImg->iColorsUsed;
                     iIndex++, iColor += iIncrement) {
                        pImg->aucPalette[iIndex][0] = (UCHAR)iColor;
                        pImg->aucPalette[iIndex][1] = (UCHAR)iColor;
                        pImg->aucPalette[iIndex][2] = (UCHAR)iColor;
                }
                /* Just to be sure */
                pImg->bColorImage = FALSE;
        }

        pImg->eCompression = compression_zlib;

        return TRUE;
} /* end of bExaminePNG */

/*
 * bExamineWMF - Examine a WMF header
 *
 * return TRUE if successful, otherwise FALSE
 */
static BOOL
bExamineWMF(FILE *pFile, imagedata_type *pImg)
{
        ULONG   ulFileSize, ulMaxRecord, ulMagic;
        USHORT  usType, usHeaderSize, usVersion, usNoObjects;

        usType = usNextWord(pFile);
        usHeaderSize = usNextWord(pFile);
        ulMagic = ((ULONG)usHeaderSize << 16) | (ULONG)usType;
        usVersion = usNextWord(pFile);
        ulFileSize = ulNextLong(pFile);
        usNoObjects = usNextWord(pFile);
        ulMaxRecord = ulNextLong(pFile);

        DBG_HEX(ulMagic);
        DBG_DEC(usType);
        DBG_DEC(usHeaderSize);
        DBG_HEX(usVersion);
        DBG_DEC(ulFileSize);
        DBG_DEC(usNoObjects);
        DBG_DEC(ulMaxRecord);

        return FALSE;
} /* end of bExamineWMF */

#if !defined(__riscos)
/*
 * vImage2Papersize - make sure the image fits on the paper
 *
 * This function should not be needed if Word would do a proper job
 */
static void
vImage2Papersize(imagedata_type *pImg)
{
        static int      iNetPageHeight = -1;
        static int      iNetPageWidth = -1;
        options_type    tOptions;
        double  dVerFactor, dHorFactor, dFactor;

        DBG_MSG("vImage2Papersize");

        fail(pImg == NULL);

        if (iNetPageHeight < 0 || iNetPageWidth < 0) {
                /* Get the page dimensions from the options */
                vGetOptions(&tOptions);
                /* Add 999 to err on the save side */
                iNetPageHeight = tOptions.iPageHeight -
                                (lDrawUnits2MilliPoints(
                                        PS_TOP_MARGIN + PS_BOTTOM_MARGIN) +
                                        999) / 1000;
                iNetPageWidth = tOptions.iPageWidth -
                                (lDrawUnits2MilliPoints(
                                        PS_LEFT_MARGIN + PS_RIGHT_MARGIN) +
                                        999) / 1000;
                DBG_DEC(iNetPageHeight);
                DBG_DEC(iNetPageWidth);
        }

        if (pImg->iVerSizeScaled < iNetPageHeight &&
            pImg->iHorSizeScaled < iNetPageWidth) {
                /* The image fits on the paper */
                return;
        }

        dVerFactor = (double)iNetPageHeight / (double)pImg->iVerSizeScaled;
        dHorFactor = (double)iNetPageWidth / (double)pImg->iHorSizeScaled;
        dFactor = min(dVerFactor, dHorFactor);
        DBG_FLT(dFactor);
        /* Round down, just to be on the save side */
        pImg->iVerSizeScaled = (int)(pImg->iVerSizeScaled * dFactor);
        pImg->iHorSizeScaled = (int)(pImg->iHorSizeScaled * dFactor);
} /* end of vImage2Papersize */
#endif /* !__riscos */

/*
 * tFind6Image - skip until the image is found
 *
 * Find the image in Word 6/7 files
 *
 * returns the new position when a image is found, otherwise -1
 */
static size_t
tFind6Image(FILE *pFile, size_t tPosition, size_t tLength,
        imagetype_enum *peImageType)
{
        ULONG   ulMarker;
        size_t  tRecordLength, tToSkip;
        USHORT  usMarker;

        fail(pFile == NULL);
        fail(peImageType == NULL);

        *peImageType = imagetype_is_unknown;
        if (tPosition + 18 >= tLength) {
                return (size_t)-1;
        }

        ulMarker = ulNextLong(pFile);
        if (ulMarker != 0x00090001) {
                DBG_HEX(ulMarker);
                return (size_t)-1;
        }
        usMarker = usNextWord(pFile);
        if (usMarker != 0x0300) {
                DBG_HEX(usMarker);
                return (size_t)-1;
        }
        (void)tSkipBytes(pFile, 10);
        usMarker = usNextWord(pFile);
        if (usMarker != 0x0000) {
                DBG_HEX(usMarker);
                return (size_t)-1;
        }
        tPosition += 18;

        while (tPosition + 6 <= tLength) {
                tRecordLength = (size_t)ulNextLong(pFile);
                usMarker = usNextWord(pFile);
                tPosition += 6;
                NO_DBG_DEC(tRecordLength);
                NO_DBG_HEX(usMarker);
                switch (usMarker) {
                case 0x0000:
                        DBG_HEX(ulGetDataOffset(pFile));
                        return (size_t)-1;
                case 0x0b41:
                        DBG_MSG("DIB");
                        *peImageType = imagetype_is_dib;
                        tPosition += tSkipBytes(pFile, 20);
                        return tPosition;
                case 0x0f43:
                        DBG_MSG("DIB");
                        *peImageType = imagetype_is_dib;
                        tPosition += tSkipBytes(pFile, 22);
                        return tPosition;
                default:
                        if (tRecordLength < 3) {
                                break;
                        }
                        if (tRecordLength > SIZE_T_MAX / 2) {
                                /*
                                 * No need to compute the number of bytes
                                 * to skip
                                 */
                                DBG_DEC(tRecordLength);
                                DBG_HEX(tRecordLength);
                                DBG_FIXME();
                                return (size_t)-1;
                        }
                        tToSkip = tRecordLength * 2 - 6;
                        if (tToSkip > tLength - tPosition) {
                                /* You can't skip this number of bytes */
                                DBG_DEC(tToSkip);
                                DBG_DEC(tLength - tPosition);
                                return (size_t)-1;
                        }
                        tPosition += tSkipBytes(pFile, tToSkip);
                        break;
                }
        }

        return (size_t)-1;
} /* end of tFind6Image */

/*
 * tFind8Image - skip until the image is found
 *
 * Find the image in Word 8/9/10 files
 *
 * returns the new position when a image is found, otherwise -1
 */
static size_t
tFind8Image(FILE *pFile, size_t tPosition, size_t tLength,
        imagetype_enum *peImageType)
{
        size_t  tRecordLength, tNameLen;
        USHORT  usRecordVersion, usRecordType, usRecordInstance;
        USHORT  usTmp;

        fail(pFile == NULL);
        fail(peImageType == NULL);

        *peImageType = imagetype_is_unknown;
        while (tPosition + 8 <= tLength) {
                usTmp = usNextWord(pFile);
                usRecordVersion = usTmp & 0x000f;
                usRecordInstance = usTmp >> 4;
                usRecordType = usNextWord(pFile);
                tRecordLength = (size_t)ulNextLong(pFile);
                tPosition += 8;
                NO_DBG_HEX(usRecordVersion);
                NO_DBG_HEX(usRecordInstance);
                NO_DBG_HEX(usRecordType);
                NO_DBG_DEC(tRecordLength);
                switch (usRecordType) {
                case 0xf000: case 0xf001: case 0xf002: case 0xf003:
                case 0xf004: case 0xf005:
                        break;
                case 0xf007:
                        tPosition += tSkipBytes(pFile, 33);
                        tNameLen = (size_t)iNextByte(pFile);
                        tPosition++;
                        DBG_DEC_C(tNameLen != 0, tNameLen);
                        tPosition += tSkipBytes(pFile, 2 + tNameLen * 2);
                        break;
                case 0xf008:
                        tPosition += tSkipBytes(pFile, 8);
                        break;
                case 0xf009:
                        tPosition += tSkipBytes(pFile, 16);
                        break;
                case 0xf006: case 0xf00a: case 0xf00b: case 0xf00d:
                case 0xf00e: case 0xf00f: case 0xf010: case 0xf011:
                case 0xf122:
                        tPosition += tSkipBytes(pFile, tRecordLength);
                        break;
                case 0xf01a:
                        DBG_MSG("EMF");
                        *peImageType = imagetype_is_emf;
                        tPosition += tSkipBytes(pFile, 50);
                        if ((usRecordInstance ^ MSOBI_EMF) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf01b:
                        DBG_MSG("WMF");
                        *peImageType = imagetype_is_wmf;
                        tPosition += tSkipBytes(pFile, 50);
                        if ((usRecordInstance ^ MSOBI_WMF) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf01c:
                        DBG_MSG("PICT");
                        *peImageType = imagetype_is_pict;
                        tPosition += tSkipBytes(pFile, 50);
                        if ((usRecordInstance ^ MSOBI_PICT) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf01d:
                        DBG_MSG("JPEG");
                        *peImageType = imagetype_is_jpeg;
                        tPosition += tSkipBytes(pFile, 17);
                        if ((usRecordInstance ^ MSOBI_JPEG) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf01e:
                        DBG_MSG("PNG");
                        *peImageType = imagetype_is_png;
                        tPosition += tSkipBytes(pFile, 17);
                        if ((usRecordInstance ^ MSOBI_PNG) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf01f:
                        DBG_MSG("DIB");
                        /* DIB is a BMP minus its 14 byte header */
                        *peImageType = imagetype_is_dib;
                        tPosition += tSkipBytes(pFile, 17);
                        if ((usRecordInstance ^ MSOBI_DIB) == 1) {
                                tPosition += tSkipBytes(pFile, 16);
                        }
                        return tPosition;
                case 0xf00c:
                default:
                        DBG_HEX(usRecordType);
                        DBG_DEC_C(tRecordLength % 4 != 0, tRecordLength);
                        DBG_FIXME();
                        return (size_t)-1;
                }
        }

        return (size_t)-1;
} /* end of tFind8Image */

/*
 * eExamineImage - Examine the image
 *
 * Returns an indication of the amount of information found
 */
image_info_enum
eExamineImage(FILE *pFile, ULONG ulFileOffsetImage, imagedata_type *pImg)
{
        long    lTmp;
        size_t  tWordHeaderLen, tLength, tPos;
        int     iType, iHorSize, iVerSize;
        USHORT  usHorScalingFactor, usVerScalingFactor;

        if (ulFileOffsetImage == FC_INVALID) {
                return image_no_information;
        }
        DBG_HEX(ulFileOffsetImage);

        if (!bSetDataOffset(pFile, ulFileOffsetImage)) {
                return image_no_information;
        }

        tLength = (size_t)ulNextLong(pFile);
        DBG_DEC(tLength);
        if (tLength < 46) {
                /* Smaller than the smallest known header */
                DBG_FIXME();
                return image_no_information;
        }
        tWordHeaderLen = (size_t)usNextWord(pFile);
        DBG_DEC(tWordHeaderLen);
        fail(tWordHeaderLen != 46 &&
                tWordHeaderLen != 58 &&
                tWordHeaderLen != 68);

        if (tLength < tWordHeaderLen) {
                /* Smaller than the current header */
                return image_no_information;
        }
        iType = (int)usNextWord(pFile);
        DBG_DEC(iType);
        (void)tSkipBytes(pFile, 28 - 8);

        lTmp = lTwips2MilliPoints(usNextWord(pFile));
        iHorSize = (int)(lTmp / 1000);
        if (lTmp % 1000 != 0) {
                iHorSize++;
        }
        DBG_DEC(iHorSize);
        lTmp = lTwips2MilliPoints(usNextWord(pFile));
        iVerSize = (int)(lTmp / 1000);
        if (lTmp % 1000 != 0) {
                iVerSize++;
        }
        DBG_DEC(iVerSize);

        usHorScalingFactor = usNextWord(pFile);
        DBG_DEC(usHorScalingFactor);
        usVerScalingFactor = usNextWord(pFile);
        DBG_DEC(usVerScalingFactor);

        /* Sanity checks */
        lTmp = (long)iHorSize * (long)usHorScalingFactor;
        if (lTmp < 2835) {
                /* This image would be less than 1 millimeter wide */
                DBG_DEC(lTmp);
                return image_no_information;
        }
        lTmp = (long)iVerSize * (long)usVerScalingFactor;
        if (lTmp < 2835) {
                /* This image would be less than 1 millimeter high */
                DBG_DEC(lTmp);
                return image_no_information;
        }

        /* Skip the rest of the header */
        (void)tSkipBytes(pFile, tWordHeaderLen - 36);
        tPos = tWordHeaderLen;

        (void)memset(pImg, 0, sizeof(*pImg));

        switch (iType) {
        case   7:
        case   8:
                tPos = tFind6Image(pFile, tPos, tLength, &pImg->eImageType);
                if (tPos == (size_t)-1) {
                        /* No image found */
                        return image_no_information;
                }
                DBG_HEX(tPos);
                break;
        case  94:       /* Word 6/7, no image just a pathname */
                pImg->eImageType = imagetype_is_external;
                DBG_HEX(ulFileOffsetImage + tPos);
                break;
        case 100:
                tPos = tFind8Image(pFile, tPos, tLength, &pImg->eImageType);
                if (tPos == (size_t)-1) {
                        /* No image found */
                        return image_no_information;
                }
                DBG_HEX(tPos);
                break;
        case 102:       /* Word 8/9/10, no image just a pathname or URL */
                pImg->eImageType = imagetype_is_external;
                DBG_HEX(ulFileOffsetImage + tPos);
                break;
        default:
                DBG_DEC(iType);
                DBG_HEX(ulFileOffsetImage + tPos);
                DBG_FIXME();
                return image_no_information;
        }

        /* Minimal information is now available */
        pImg->tLength = tLength;
        pImg->tPosition = tPos;
        pImg->iHorSizeScaled =
                (int)(((long)iHorSize * (long)usHorScalingFactor + 500) / 1000);
        pImg->iVerSizeScaled =
                (int)(((long)iVerSize * (long)usVerScalingFactor + 500) / 1000);
#if !defined(__riscos)
        vImage2Papersize(pImg);
#endif /* !__riscos */

        /* Image type specific examinations */
        switch (pImg->eImageType) {
        case imagetype_is_dib:
                if (bExamineDIB(pFile, pImg)) {
                        return image_full_information;
                }
                return image_minimal_information;
        case imagetype_is_jpeg:
                if (bExamineJPEG(pFile, pImg)) {
                        return image_full_information;
                }
                return image_minimal_information;
        case imagetype_is_png:
                if (bExaminePNG(pFile, pImg)) {
                        return image_full_information;
                }
                return image_minimal_information;
        case imagetype_is_wmf:
                if (bExamineWMF(pFile, pImg)) {
                        return image_full_information;
                }
                return image_minimal_information;
        case imagetype_is_emf:
        case imagetype_is_pict:
        case imagetype_is_external:
                return image_minimal_information;
        case imagetype_is_unknown:
        default:
                return image_no_information;
        }
} /* end of eExamineImage */

---