home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / packery / xpk_source / libraries / nuke / xpknuke.c < prev   
C/C++ Source or Header  |  1996-10-19  |  4KB  |  174 lines
  1. /*
  2.  * This library is mainly intended to demonstrate how to program a sub
  3.  * library.
  4.  */
  5.  
  6. #include <xpk/xpksub.h>
  7. #include <exec/memory.h>
  8. #include <pragma/exec_lib.h>
  9.  
  10. #define SDI_TO_ANSI
  11. #include "SDI_ASM_STD_protos.h"
  12.  
  13. #define SCANBUFLEN 32768
  14.  
  15. /*
  16.  * Pack a chunk
  17.  */
  18.  
  19. struct NukeData {
  20.     APTR    inbuf;
  21.     APTR    outbuf;
  22.     APTR    last;
  23.     APTR    next;
  24.     CPTR    cwri;
  25.     CPTR    uwri;
  26.     CPTR    uend;
  27.     CPTR    delpos;
  28.     UWORD    ulen;
  29.     UWORD    clen;
  30.     UWORD    ustop;
  31.     UWORD    ustart;
  32.     UWORD    ucount;
  33.     UWORD    scanrange;
  34.     UWORD    room1;
  35.     UWORD    room2;
  36.     UWORD    room4;
  37.     UWORD    roomN;
  38.     UWORD    data1;
  39.     UWORD    data2;
  40.     ULONG    data4;
  41.     ULONG    dataN;
  42.     CPTR    dest1;
  43.     CPTR    dest2;
  44.     CPTR    dest4;
  45.     CPTR    destN;
  46.     ULONG    dummy;
  47.     CPTR    contbuf;
  48.     ULONG    flags;
  49. };
  50.  
  51. #ifdef __cplusplus
  52. extern "C" {
  53. #endif
  54.  
  55. LONG __asm AsmPack  (register __a4 struct NukeData *ND);
  56. STRPTR __asm AsmUnpack(register __a1 STRPTR wread, register __a4 STRPTR bread,
  57.                         register __a0 STRPTR dst, register __a2 STRPTR end);
  58. #ifdef __cplusplus
  59. }
  60. #endif
  61.  
  62. #define PACKMEM   (65536+SCANBUFLEN)*sizeof(UWORD)+sizeof(struct NukeData)
  63.  
  64. static struct XpkMode NukeMode = {
  65.   NULL,       // Next mode
  66.   100,        // Handles up to
  67.   XPKMF_A3000SPEED,      // Flags
  68.   PACKMEM,    // Packing memory
  69.   0,          // Unpacking memory
  70.   36,         // Packing speed
  71.   630,        // Unpacking speed
  72.   454,        // Compression ratio
  73.   0,          // Reserved
  74.   "normal",   // Description
  75. };
  76.  
  77. static struct XpkInfo NukeInfo = {
  78.     1,               /* info version */
  79.     1,               /* lib  version */
  80.     0,               /* master vers  */
  81.     1,               /* ModesVersion */
  82.     "NUKE"  ,        /* short name   */
  83.     "Nuke",          /* long name    */
  84.     "A relatively efficient packer that unpacks very quickly", /* Description */
  85.     0x4E554B45,    /* 'NUKE', 4 letter ID  */
  86.     XPKIF_PK_CHUNK | /* flags        */
  87.     XPKIF_UP_CHUNK,
  88.     30000,           /* max in chunk */
  89.     10,              /* min in chunk */
  90.     30000,           /* def in chunk */
  91.     "Nuking",        /* pk message   */
  92.     "Unnuking",      /* up message   */
  93.     "Nuked",         /* pk past msg  */
  94.     "Unnuked",       /* up past msg  */
  95.     50,              /* DefMode      */
  96.     0,               /* Pad          */
  97.     &NukeMode,       /* ModeDesc     */
  98.     0,               /* MinModeDesc  */
  99.     0,               /* MaxModeDesc  */
  100.     {0}              /* reserved     */
  101. };
  102.  
  103.  
  104. /*
  105.  * Returns an info structure about our packer
  106.  */
  107.  
  108. struct XpkInfo * __asm XpksPackerInfo(void)
  109. {
  110.     return &NukeInfo;
  111. }
  112.  
  113. void __asm XpksPackFree(register __a0 struct XpkSubParams *xpar)
  114. {
  115.   struct NukeData *ND=(struct NukeData *)xpar->Sub[0];
  116.  
  117.   if(!ND)
  118.     return;
  119.   if( ND->last ) FreeMem( ND->last, 65536     *sizeof(UWORD));
  120.   if( ND->next ) FreeMem( ND->next, SCANBUFLEN*sizeof(UWORD));
  121.   FreeMem( ND, sizeof(struct NukeData));
  122. }
  123.  
  124. struct NukeData *alloctabs(struct XpkSubParams *xpar)
  125. {
  126.   struct NukeData *ND;
  127.  
  128.   if ((xpar->Sub[0] = (LONG) (ND = (struct NukeData *) AllocMem(sizeof(struct NukeData),MEMF_CLEAR))) &&
  129.       (ND->last = AllocMem(65536*sizeof(UWORD),0)) &&
  130.       (ND->next = AllocMem(SCANBUFLEN*sizeof(UWORD),0)))
  131.     return ND;
  132.   else
  133.   {
  134.     XpksPackFree(xpar);
  135.     return 0;
  136.   }
  137. }
  138.  
  139. LONG __asm XpksPackChunk(register __a0 struct XpkSubParams *xpar)
  140. {
  141.   struct NukeData *ND = (struct NukeData *)xpar->Sub[0];
  142.  
  143.   if (!ND)
  144.     if (!(ND=alloctabs(xpar)))
  145.       return XPKERR_NOMEM;
  146.  
  147.   ND->inbuf = xpar->InBuf;
  148.   ND->outbuf= xpar->OutBuf;
  149.   ND->ulen  = xpar->InLen;
  150.   ND->clen  = xpar->OutBufLen-4;
  151.  
  152.   memset(ND->last,0,65536*sizeof(UWORD));
  153.   memset(ND->next,0,SCANBUFLEN*sizeof(UWORD));
  154.  
  155.   if((xpar->OutLen = AsmPack(ND))<0 || xpar->OutLen>xpar->InLen)
  156.     return XPKERR_EXPANSION;
  157.   return 0;
  158. }
  159.  
  160. LONG __asm XpksUnpackChunk(register __a0 struct XpkSubParams *xpar)
  161. {
  162. //  APTR end;
  163.  
  164. //  end=
  165.   AsmUnpack(xpar->InBuf,  (STRPTR)xpar->InBuf  + xpar->InLen,
  166.             xpar->OutBuf, (STRPTR)xpar->OutBuf + xpar->OutLen);
  167.  
  168. //  if( xpar->OutBuf+xpar->OutLen != end )
  169. //    return XPKERR_CORRUPTPKD;
  170.  
  171.   return 0;
  172. }
  173.  
  174.