Initial import of the CDE 2.1.30 sources from the Open Group.

cde/lib/DtHelp/il/iljpgencode.c

@@ -0,0 +1,263 @@
+/* $XConsortium: iljpgencode.c /main/3 1995/10/23 15:55:46 rswiston $ */
+/**---------------------------------------------------------------------
+***	
+***    (c)Copyright 1992 Hewlett-Packard Co.
+***    
+***                             RESTRICTED RIGHTS LEGEND
+***    Use, duplication, or disclosure by the U.S. Government is subject to
+***    restrictions as set forth in sub-paragraph (c)(1)(ii) of the Rights in
+***    Technical Data and Computer Software clause in DFARS 252.227-7013.
+***                             Hewlett-Packard Company
+***                             3000 Hanover Street
+***                             Palo Alto, CA 94304 U.S.A.
+***    Rights for non-DOD U.S. Government Departments and Agencies are as set
+***    forth in FAR 52.227-19(c)(1,2).
+***
+***-------------------------------------------------------------------*/
+
+#include "iljpgencodeint.h"
+
+
+    /*  -------------------- iljpgEncodeInit -------------------------- */
+    /*  Init for JPEG encoding and return ptr to private block.
+    */
+    ILJPG_PUBLIC
+iljpgError iljpgEncodeInit (
+    register iljpgDataPtr pData,
+    iljpgPtr           *pPrivate                /* RETURNED */
+    )
+{
+    register iljpgEncodePrivPtr pPriv;
+    register iljpgECompPtr pComp;
+    iljpgCompDataPtr    pCompData;
+    int                 comp;
+    iljpgError          error;
+    register unsigned int   index, i;
+
+        /*  Validate *pData: valid hori/vertFactor, tables present, etc. */
+    if (!_iljpgValidPars (pData))
+        return ILJPG_ERROR_ENCODE_PARS;
+
+        /*  Allocate and return private block */
+    pPriv = (iljpgEncodePrivPtr)ILJPG_MALLOC_ZERO (sizeof (iljpgEncodePrivRec));
+    if (!pPriv)
+        return ILJPG_ERROR_ENCODE_MALLOC;
+    pPriv->pData = pData;
+    *pPrivate = (iljpgPtr)pPriv;
+
+        /*  For DCT encoding, get and store into private a
+            scaled version of each Q table.
+        */
+    for (i = 0; i < 4; i++)
+        pPriv->DCTScaleTables[i] = (float *)NULL;
+    for (i = 0; i < 4; i++) {
+        if (pData->QTables[i]) {
+            if (!(pPriv->DCTScaleTables[i] = (float *)ILJPG_MALLOC(sizeof(float) * 64)))
+                return ILJPG_ERROR_ENCODE_MALLOC;
+            if (error = _iljpgEnDCTScale (pData->QTables[i], pPriv->DCTScaleTables[i]))
+                return error;
+            }
+        }
+
+        /*  Init Huffman encoding */
+    if (error = _iljpgEnhuffInit (pPriv))
+        return error;
+
+        /*  Setup static part of per-comp data; copy from other places */
+    for (comp = 0, pCompData = pData->comp, pComp = pPriv->compData; 
+      comp < pData->nComps; comp++, pCompData++, pComp++) {
+        pComp->pScale = pPriv->DCTScaleTables[pCompData->QTableIndex];
+        pComp->horiFactor = pCompData->horiFactor;
+        pComp->vertFactor = pCompData->vertFactor;
+        pComp->width = pData->width * pCompData->horiFactor / pData->maxHoriFactor;
+        pComp->mcuXInc = 8 * pCompData->horiFactor;
+        pComp->mcuYInc = 8 * pCompData->vertFactor;
+        }
+
+    return 0;
+}
+
+
+    /*  -------------------- iljpgEncodeCleanup -------------------------- */
+    /*  Cleanup after JPEG encoding.
+    */
+    ILJPG_PUBLIC
+iljpgError iljpgEncodeCleanup (
+    iljpgPtr            pPrivate
+    )
+{
+    register int        i;
+    register iljpgEncodePrivPtr pPriv;
+    iljpgError          error;
+
+        /*  Free any scaled Q tables created by Init() */
+    pPriv = (iljpgEncodePrivPtr)pPrivate;
+    for (i = 0; i < 4; i++) 
+        if (pPriv->DCTScaleTables[i])
+            ILJPG_FREE (pPriv->DCTScaleTables[i]);
+
+        /*  Cleanup Huffman */
+    error = _iljpgEnhuffCleanup(pPriv);
+
+        /*  Free the given private data.  Note that pPrivate->pData is not
+            freed; that is done when the caller calls iljpgFreeData().
+        */
+    ILJPG_FREE (pPrivate);
+
+    return error;
+}
+
+
+
+    /*  -------------------- iljpgEncodeExecute -------------------------- */
+    /*  Encode (compress) the pixels from the per-plane buffers pointed to 
+        by "pSrcPixels": one ptr per component (# of components = "nComps" in 
+        the iljpgData passed to iljpgEncodeInit()).  "nSrcBytesPerRow" is length
+        of each row in the corresponding buffers in "pSrcPixels".  
+        "pPrivate" is the ptr returned by iljpgEncodeInit().
+        "nSrcLines" is the # of lines to read; encoding stops when nSrcLines
+        lines have been encoded.
+    */
+    ILJPG_PUBLIC
+iljpgError iljpgEncodeExecute (
+    iljpgPtr            pPrivate,
+    ILJPG_ENCODE_STREAM stream,
+    long                nSrcLines,
+    iljpgPtr            pSrcPixels[],
+    long                nSrcBytesPerRow[]
+    )
+{
+    iljpgEncodePrivPtr  pPriv;
+    iljpgDataPtr        pData;
+    register iljpgECompPtr pComp;
+    iljpgPtr            pPixels;
+    iljpgError          error;
+    long                nBytesPerRow, mcuMaxX, mcuMaxY, bX, bY;
+    int                 comp, v, h, mcuWidth, mcuHeight;
+    int                 pixels[64];
+
+    pPriv = (iljpgEncodePrivPtr)pPrivate;
+    pData = pPriv->pData;
+
+        /*  Encode "interleaved" JPEG data, where all components are grouped together
+            in Minimum Coded Unit (MCU) size, = 8 * max hori(width) or vert(height)
+            factor.  The "factors" are the inverse of IL subsample factors.  For
+            example, if component 0 is not subsampled and 1 and 2 are subsampled by 2,
+            then hori/vertFactor for comp 0 is 2, for comps 1..2 is 1, and max hori/vert
+            factor is 2 (there are 4x as many comp 0 pixels as comps 1 or 2).
+                So: loop over y, and over x within y, and decode one MCU (all components),
+            advancing x by mcuWidth and y by mcuHeight.
+        */
+    mcuWidth = 8 * pData->maxHoriFactor;
+    mcuHeight = 8 * pData->maxVertFactor;
+
+        /*  Reset temp vars in comp data in private; "height" is size of one strip */
+    for (comp = 0, pComp = pPriv->compData; comp < pData->nComps; comp++, pComp++) {
+        pComp->height = nSrcLines * pComp->vertFactor / pData->maxVertFactor;
+        pComp->x = 0;
+        pComp->y = 0;
+        pComp->lastDC = 0;          /* new strip; clear as if a reset/restart */
+        }
+
+        /*  Loop over y, and over x within y, and encode one MCU (all components),
+            advancing x by mcuWidth and y by mcuHeight.
+        */
+    for (mcuMaxY = 0; mcuMaxY < nSrcLines; mcuMaxY += mcuHeight) {
+        for (mcuMaxX = 0; mcuMaxX < pData->width; mcuMaxX += mcuWidth) {
+
+            /*  Encode one MCU, all components, to (mcuX, mcuY). For each component 
+                there are horiFactor * vertFactor 8x8 blocks that go across then down.
+            */
+            for (comp = 0, pComp = pPriv->compData; comp < pData->nComps; comp++, pComp++) {
+                nBytesPerRow = nSrcBytesPerRow[comp];
+                pPixels = pSrcPixels[comp];
+
+                for (v = 0, bY = pComp->y; v < pComp->vertFactor; v++, bY += 8) {
+                    for (h = 0, bX = pComp->x; h < pComp->horiFactor; h++, bX += 8) {
+
+                            /*  Extract one 8x8 block from position (bX, bY).  If
+                                clipped replicate pixel or above scan line out to 8x8.
+                            */
+                        {   int             nBytesInit;
+                            register int    nLines, nBytesM1, *pDst, *pDstLine;
+                            register iljpgPtr pSrc, pSrcLine;
+
+                            nLines = pComp->height - bY;
+                            if (nLines > 8) 
+                                nLines = 8;
+                            nBytesInit = pComp->width - bX;
+                            if (nBytesInit > 8) 
+                                nBytesInit = 8;
+                            if ((nLines > 0) && (nBytesInit > 0)) {
+                                pSrcLine = pPixels + (bY * nBytesPerRow) + bX;
+                                pDstLine = pixels;
+
+                                    /*  If clipped; do nLines, replicate at right edge */
+                                if ((nLines < 8) || (nBytesInit < 8)) {
+                                    int     i, j, pixel;
+                                    for (i = 0; i < nLines; i++) {
+                                        pSrc = pSrcLine;
+                                        pSrcLine += nBytesPerRow;
+                                        pDst = pDstLine;
+                                        pDstLine += 8;
+                                        for (j = 0; j < nBytesInit; j++)
+                                            *pDst++ = pixel = *pSrc++;
+                                        for (j = nBytesInit; j < 8; j++)
+                                            *pDst++ = pixel;    /* replicate right */
+                                        }
+                                        /*  Replicate last dst line out to 8 lines */
+                                    pDst = pDstLine;
+                                    pDstLine -= 8;              /* back up one line */
+                                    for (i = nLines; i < 8; i++) {
+                                        for (j = 0; j < 8; j++)
+                                            *pDst++ = pDstLine[j];
+                                        }
+                                    }   /* END clipped */
+                                else {  /* all 8x8 available; do simple case */
+                                    nLines--;               /* make # lines/bytes - 1 */
+                                    nBytesInit--;
+                                    do {
+                                        nBytesM1 = nBytesInit;
+                                        pSrc = pSrcLine;
+                                        pSrcLine += nBytesPerRow;
+                                        pDst = pDstLine;
+                                        pDstLine += 8;
+                                        do {
+                                            *pDst++ = *pSrc++;
+                                            } while (--nBytesM1 >= 0);
+                                        } while (--nLines >= 0);
+                                    }
+                                }
+                        }
+
+                            /*  Do DCT encoding, from "pixels" back into "pixels" */
+                        _iljpgEnDCT (pixels, pComp->pScale);
+
+                            /*  Subtract previous DC from this one, save this one for next */
+                        {   int     dc;
+                            dc = pixels[0];
+                            pixels[0] = dc - pComp->lastDC;
+                            pComp->lastDC = dc;
+                        }
+
+                            /*  Do Huffman encoding of block */
+                        if (error = _iljpgEnhuffExecute (pPriv, comp, pixels, stream))
+                            return error;
+                        }   /* END hori, one 8x8 block */
+                    }       /* END vert */
+
+                pComp->x += pComp->mcuXInc;     /* move component one MCU to right */
+                }       /* END one component */
+            }           /* END one hori MCU */
+
+          /*  Move each component one MCU down, reset to left edge */
+        for (comp = 0, pComp = pPriv->compData; comp < pData->nComps; comp++, pComp++) {
+            pComp->y += pComp->mcuYInc;
+            pComp->x = 0;
+            }
+        }             /* END one vert MCU */
+
+        /*  Flush any bits not yet output from Huffman encoding and exit */
+    return _iljpgEnhuffFlush (pPriv, stream);
+}
+