windows-server-2003/printscan/faxsrv/setup/win9xupg/awd/resexec/hre.c

/*
**  Copyright (c) 1991 Microsoft Corporation
*/
//===========================================================================
// FILE                         HRE.C
//
// MODULE                       Host Resource Executor
//
// PURPOSE                      Convert A-form to B-form for jumbo driver
//
// DESCRIBED IN                 Resource Executor design spec.
//
// MNEMONICS                    n/a
// 
// HISTORY  1/17/92 mslin       created
//          3/30/92 mslin       Pre-compiled brush generated for each job.
//                              ideal case would be initialize PcrBrush in
//                              HRE.DLL loading, and free up when HRE 
//                              terminate. but we had problem in Dumbo, ???
//                              Expanded Brush Buffer allocated for each job.
//                              lpgBrush will be set to lpREState->lpBrushBuf
//                              in DoRpl().
//          4/15/92 mslin       added uiHREExecuteRPL() for dumbo.
//          9/27/93 mslin       added a new bit of wFlags in hHREOpen() for
//                              300/600 dpi:
//                                  bit2: 0 -- 300 dpi
//                                  bit2: 1 -- 600 dpi
//                              also remove DUMBO compiler switch. 
//          2/09/94 rajeevd     Undid all of the above changes.
//===========================================================================

// include file
#include <windows.h>
#include <windowsx.h>
#include <resexec.h>

#include "constant.h"
#include "jtypes.h"     // type definition used in cartridge
#include "jres.h"       // cartridge resource data type definition
#include "hretype.h"    // define data structure used by hre.c and rpgen.c

#include "hreext.h"
#include "multbyte.h"   // define macros to take care of byte ordering

#define HRE_SUCCESS             0x0     // successful return from HRE
#define HRE_EXECUTED_RPL        0x01    // Executed the final RP in an RPL
#define HRE_EXECUTED_ONE        0x02    // Executed only one RP from an RPL
                                        // (not the last one)
#define HRE_ERROR               0x03    // General HRE failure

// PRIVATE functions
static   UINT        PutRPL(LPHRESTATE lpHREState, LPFRAME lpFrameArray,
                     UINT uiCount);
static   UINT        FreeRPL(LPRPLLIST lpRPL);

#ifdef DEBUG
DWORD    dwrgTime[MAXBAND];
SHORT    sCurrentLine;
ULONG    ulgPageId = 0;
ULONG    ulgTimes[1000] = {0};
#endif

#include "windows.h"

//==============================================================================

#ifndef WIN32

BOOL WINAPI LibMain
    (HANDLE hInst, WORD wSeg, WORD wHeap, LPSTR lpszCmd)
{ return 1; }

int WINAPI WEP (int nParam);
#pragma alloc_text(INIT_TEXT,WEP)
int WINAPI WEP (int nParam)
{ return 1; }

#endif

//==============================================================================
HANDLE                 // context handle (NULL on failure)
WINAPI hHREOpen
(
    LPVOID lpBrushPat,   // array of 32x32 brush patterns
    UINT   cbLine,       // maximum page width in bytes
    UINT   cResDir       // entries in resource directory
)
{
   HANDLE      hHREState;
   LPHRESTATE  lpHREState;
   LPRESTATE   lpREState;
   LPRESDIR    lpDlResDir;

   // create a handle for the new session 
   if (!(hHREState = GlobalAlloc(GMEM_MOVEABLE, sizeof(HRESTATE))))
      return (NULL);
   lpHREState = (LPHRESTATE) GlobalLock (hHREState);

   // allocate Download ResDir Table
   if (!(lpDlResDir = (LPRESDIR) GlobalAllocPtr (GMEM_ZEROINIT, sizeof(RESDIR) * cResDir)))
   {
      // unlock and free HRESTATE
      GlobalUnlock(hHREState);
      GlobalFree(hHREState);
      return(NULL);
   }
   
   // allocate RESTATE data structure and Initialize it
   // this is graphic state of rendering 
   if (!(lpREState = (LPRESTATE) GlobalAllocPtr (GMEM_ZEROINIT, sizeof(RESTATE))))
   {
      GlobalUnlock(hHREState);
      GlobalFree(hHREState);
      GlobalFreePtr (lpDlResDir);
      return (NULL);
   }

#ifdef WIN32

  lpREState->lpBrushBuf = NULL;

#else

   if (!(lpREState->lpBrushBuf = (LPSTR) GlobalAllocPtr(GMEM_MOVEABLE, (cbLine + 4) * 16)))
   {
      GlobalUnlock(hHREState);
      GlobalFree(hHREState);
      GlobalFreePtr (lpDlResDir);
      GlobalFreePtr (lpREState);
      return (NULL);
   }

#endif
      
   // Initialize RESTATE
   lpREState->lpBrushPat = lpBrushPat;
                                            
   // Initialize HRESTATE
   lpHREState->hHREState = hHREState;
   lpHREState->scDlResDir = (USHORT)cResDir;
   lpHREState->lpDlResDir = lpDlResDir;
   lpHREState->lpRPLHead= NULL;
   lpHREState->lpRPLTail= NULL;
   lpHREState->lpREState = lpREState;

   GlobalUnlock(hHREState);
   return(hHREState);
}

//---------------------------------------------------------------------------
UINT                            // will be zero (0) if resource is processed
                                // succesfully, otherwise it will be an error
                                // code as defined above.
WINAPI uiHREWrite
(
    HANDLE      hHREState,      // handle returned previously by hREOpen
    LPFRAME     lpFrameArray,   // FAR pointer to an array of FRAME structs
    UINT        uiCount         // Number of FRAME structs pointed to by 
                                // lpFrameArray
)

// PURPOSE                      To add a resource block (RPLK) to the
//                              HRE state hash table for the context
//                              identified by hHREState.
//
// ASSUMPTIONS & ASSERTIONS     The memory for the RBLK has allready been
//                              Allocated and locked.  HRE will not copy the
//                              data, just the pointers.
//                              The lpFrameArray does not point to an SPL.
//                              All SPL's will be handled externally to HRE.
//
// INTERNAL STRUCTURES          
//
// UNRESOLVED ISSUES            
//
//---------------------------------------------------------------------------       
{
   LPHRESTATE     lpHREState;
   LPJG_RES_HDR   lpResHdr;
   LPRESDIR       lpResDir;
   ULONG          ulUID;
   USHORT         usClass;
   HANDLE         hFrame;
   LPFRAME        lpFrameArrayDup, lpFrame;
   UINT           uiLoopCount;

   lpHREState = (LPHRESTATE) GlobalLock (hHREState);

   // get resource class                                            
   lpResHdr = (LPJG_RES_HDR )lpFrameArray->lpData;
   usClass = GETUSHORT(&lpResHdr->usClass);
   switch(usClass)
   {
      case JG_RS_RPL: /*0x4*/
         // store into RPL list
         if( PutRPL(lpHREState, lpFrameArray, uiCount) != HRE_SUCCESS )
         {
            GlobalUnlock(hHREState);
            return(HRE_ERROR);   // out of memory
         }
         break;

      case JG_RS_GLYPH: /*0x1*/
      case JG_RS_BRUSH: /*0x2*/
      case JG_RS_BITMAP: /*0x3*/
         // check to see if uid >= size of hash table then reallocate
         ulUID = GETULONG(&lpResHdr->ulUid);
         lpResDir = lpHREState->lpDlResDir;
         if (ulUID >= lpHREState->scDlResDir)
         {
               return(HRE_ERROR);
         }

         // Free frame array of previous resource block
         lpFrameArrayDup = lpResDir[ulUID].lpFrameArray;
         if(lpFrameArrayDup)
           GlobalFreePtr (lpFrameArrayDup);
          
         // copy frame array
         if (!(hFrame = GlobalAlloc(GMEM_MOVEABLE, uiCount * sizeof(FRAME))))
            return (HRE_ERROR);
         if (!(lpFrameArrayDup = (LPFRAME)GlobalLock(hFrame)))
         {
            GlobalFree(hFrame);
            return (HRE_ERROR);
         }
         lpFrame = lpFrameArrayDup;
         for(uiLoopCount=0; uiLoopCount<uiCount; uiLoopCount++)
         {
            *lpFrame++ = *lpFrameArray++;
         }

         // put into hash table
         lpResDir[ulUID].lpFrameArray = lpFrameArrayDup;
         lpResDir[ulUID].uiCount = uiCount;
         break;
         
      default:
         // error return 
         break;

   }

   GlobalUnlock(hHREState);
   return(HRE_SUCCESS);

}


//---------------------------------------------------------------------------
UINT   WINAPI uiHREExecute
(
    HANDLE   hHREState,  // resource executor context
  LPBITMAP lpbmBand,   // output band buffer
  LPVOID   lpBrushPat  // array of 32x32 brush patterns
)
{
   LPHRESTATE  lpHREState;
   LPRESTATE   lpRE;
   LPRPLLIST   lpRPL, lpRPLSave;

   lpHREState = (LPHRESTATE) GlobalLock (hHREState);
   
   // Record parameters in RESTATE.
   lpRE = lpHREState->lpREState;
   lpRE->lpBandBuffer = lpbmBand;
   lpRE->lpBrushPat   = lpBrushPat;

   lpRPL = lpHREState->lpRPLHead;
   do
   {
     DoRPL(lpHREState, lpRPL);
      lpRPLSave = lpRPL;
      lpRPL=lpRPL->lpNextRPL;
      FreeRPL(lpRPLSave);
   }
   while(lpRPL);
   // if last RP executed then update lpRPLHead
   lpHREState->lpRPLHead = lpRPL;
   
   GlobalUnlock(hHREState);
   return(HRE_EXECUTED_RPL);

}

//---------------------------------------------------------------------------
UINT                            // will be zero (0) if HRE context is closed
                                // succesfully, otherwise it will be an error
                                // code as defined above.
WINAPI uiHREClose
(
    HANDLE      hHREState       // handle returned previously by hREOpen
)

// PURPOSE                      To close a previously opened context in the
//                              HRE.  All memory and state information 
//                              associated with the context will be freed.
//
// ASSUMPTIONS & ASSERTIONS     None.
//
// INTERNAL STRUCTURES          None.
//
// UNRESOLVED ISSUES            programmer development notes
//
// --------------------------------------------------------------------------
{
   LPHRESTATE  lpHREState;
   LPRESTATE   lpRE;
   LPRESDIR    lpDlResDir;
   SCOUNT      scDlResDir;
   SCOUNT      sc;
   LPFRAME     lpFrameArray;
    
   if (!(lpHREState = (LPHRESTATE) GlobalLock (hHREState)))
     return HRE_ERROR;

   lpDlResDir = lpHREState->lpDlResDir;
   if(lpDlResDir != NULL)                 // mslin, 4/15/92 for dumbo
   {
      scDlResDir = lpHREState->scDlResDir;
      // free frame array of DlResDir
      for(sc = 0; sc < scDlResDir; sc++)
      {
         if( (lpFrameArray = lpDlResDir[sc].lpFrameArray) != NULL)
           GlobalFreePtr (lpFrameArray);
      }

      // unlock and free DlResDir
      GlobalFreePtr(lpDlResDir);
   }

     lpRE = lpHREState->lpREState;

#ifndef WIN32
   GlobalFreePtr (lpRE->lpBrushBuf);
#endif   
   GlobalFreePtr (lpRE);
   
   GlobalUnlock(hHREState);
   GlobalFree(hHREState);
   
   return(HRE_SUCCESS);
}
 
// ------------------------------------------------------------------------
static
UINT                         // HRE_SUCCESS if allocate memory OK
                             // HRE_ERROR if allocate memory failure
PutRPL
(
   LPHRESTATE lpHREState,
   LPFRAME lpFrameArray,
   UINT uiCount
)
// PURPOSE
//                            Allocate a RPL entry and then put RPL into 
//                            tail of RPL list.
//
//           
// ------------------------------------------------------------------------
{
   HANDLE      hRPL;
   LPRPLLIST   lpRPL;
   HANDLE      hFrame;
   LPFRAME     lpFrameArrayDup, lpFrame;
   UINT        uiLoopCount;

   BOOL        fAllocMemory = FALSE;
   if (hRPL = GlobalAlloc(GMEM_MOVEABLE, sizeof(RPLLIST)))
   {
        if (lpRPL = (LPRPLLIST)GlobalLock(hRPL))
        {
            if (hFrame = GlobalAlloc(GMEM_MOVEABLE, uiCount * sizeof(FRAME)))
            {
                if (lpFrameArrayDup = (LPFRAME)GlobalLock(hFrame))
                {
                    // all allocations are ok:
                    fAllocMemory = TRUE;
                }
                else
                {
                    GlobalFree(hFrame);
                    GlobalUnlock(hRPL);
                    GlobalFree(hRPL);     
                }
            }
            else
            {
                GlobalUnlock(hRPL);
                GlobalFree(hRPL);     
            }
        }
        else
        {
            GlobalFree(hRPL);
        }

   }
   
   if (!fAllocMemory)
   {
       return (HRE_ERROR);
   }


   lpFrame = lpFrameArrayDup;
   for(uiLoopCount=0; uiLoopCount<uiCount; uiLoopCount++)
   {
      *lpFrame++ = *lpFrameArray++;
   }

   lpRPL->uiCount = uiCount;
   lpRPL->lpFrame = lpFrameArrayDup;
   lpRPL->lpNextRPL = NULL;
   if(lpHREState->lpRPLHead == NULL)
   {
      // first RPL
      lpHREState->lpRPLHead = lpHREState->lpRPLTail = lpRPL;
   }
   else
   {
      lpHREState->lpRPLTail->lpNextRPL = lpRPL;
      lpHREState->lpRPLTail = lpRPL;
   }
   return(HRE_SUCCESS);
}

// ------------------------------------------------------------------------
static
UINT                            // HRE_SUCCESS if allocate memory OK
                                // HRE_ERROR if allocate memory failure
FreeRPL
(
   LPRPLLIST lpRPL
)
// PURPOSE
//                               Free a RPL entry and its frame array
//
// ------------------------------------------------------------------------
{
    GlobalFreePtr (lpRPL->lpFrame);
    GlobalFreePtr (lpRPL);
    return HRE_SUCCESS;
}