home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ELYVER10.ZIP / MIKXMAS.ZIP / source / load_xm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-12  |  15.5 KB  |  604 lines
  1. /*
  2.  
  3. Name:
  4. LOAD_XM.C
  5.  
  6. Description:
  7. Fasttracker (XM) module loader
  8.  
  9. Portability:
  10. All systems - all compilers (hopefully)
  11.  
  12. */
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <ctype.h>
  17. #include <malloc.h>
  18. #include "mikmod.h"
  19.  
  20. /**************************************************************************
  21. **************************************************************************/
  22.  
  23.  
  24. typedef struct XMHEADER{
  25.     char  id[17];                   /* ID text: 'Extended module: ' */
  26.     char  songname[21];             /* Module name, padded with zeroes and 0x1a at the end */
  27.     char  trackername[20];  /* Tracker name */
  28.     UWORD version;                  /* (word) Version number, hi-byte major and low-byte minor */
  29.     ULONG headersize;               /* Header size */
  30.     UWORD songlength;               /* (word) Song length (in patten order table) */
  31.     UWORD restart;                  /* (word) Restart position */
  32.     UWORD numchn;                   /* (word) Number of channels (2,4,6,8,10,...,32) */
  33.     UWORD numpat;                   /* (word) Number of patterns (max 256) */
  34.     UWORD numins;                   /* (word) Number of instruments (max 128) */
  35.     UWORD flags;                    /* (word) Flags: bit 0: 0 = Amiga frequency table (see below) 1 = Linear frequency table */
  36.     UWORD tempo;                    /* (word) Default tempo */
  37.     UWORD bpm;                              /* (word) Default BPM */
  38.     UBYTE orders[256];              /* (byte) Pattern order table */
  39. } XMHEADER;
  40.  
  41.  
  42. typedef struct XMINSTHEADER{
  43.     ULONG size;                             /* (dword) Instrument size */
  44.     char  name[22];                 /* (char) Instrument name */
  45.     UBYTE type;                             /* (byte) Instrument type (always 0) */
  46.     UWORD numsmp;                   /* (word) Number of samples in instrument */
  47.     ULONG ssize;                    /* */
  48. } XMINSTHEADER;
  49.  
  50.  
  51. typedef struct XMPATCHHEADER{
  52.     UBYTE what[96];         /* (byte) Sample number for all notes */
  53.     UBYTE volenv[48];       /* (byte) Points for volume envelope */
  54.     UBYTE panenv[48];       /* (byte) Points for panning envelope */
  55.     UBYTE volpts;           /* (byte) Number of volume points */
  56.     UBYTE panpts;           /* (byte) Number of panning points */
  57.     UBYTE volsus;           /* (byte) Volume sustain point */
  58.     UBYTE volbeg;           /* (byte) Volume loop start point */
  59.     UBYTE volend;           /* (byte) Volume loop end point */
  60.     UBYTE pansus;           /* (byte) Panning sustain point */
  61.     UBYTE panbeg;           /* (byte) Panning loop start point */
  62.     UBYTE panend;           /* (byte) Panning loop end point */
  63.     UBYTE volflg;           /* (byte) Volume type: bit 0: On; 1: Sustain; 2: Loop */
  64.     UBYTE panflg;           /* (byte) Panning type: bit 0: On; 1: Sustain; 2: Loop */
  65.     UBYTE vibflg;           /* (byte) Vibrato type */
  66.     UBYTE vibsweep;         /* (byte) Vibrato sweep */
  67.     UBYTE vibdepth;         /* (byte) Vibrato depth */
  68.     UBYTE vibrate;          /* (byte) Vibrato rate */
  69.     UWORD volfade;          /* (word) Volume fadeout */
  70.     UWORD reserved[11];     /* (word) Reserved */
  71. } XMPATCHHEADER;
  72.  
  73.  
  74. typedef struct XMWAVHEADER{
  75.     ULONG length;           /* (dword) Sample length */
  76.     ULONG loopstart;        /* (dword) Sample loop start */
  77.     ULONG looplength;       /* (dword) Sample loop length */
  78.     UBYTE volume;           /* (byte) Volume */
  79.     SBYTE finetune;          /* (byte) Finetune (signed byte -128..+127) */
  80.     UBYTE type;                     /* (byte) Type: Bit 0-1: 0 = No loop, 1 = Forward loop, */
  81. /*                                        2 = Ping-pong loop; */
  82. /*                                        4: 16-bit sampledata */
  83.     UBYTE panning;          /* (byte) Panning (0-255) */
  84.     SBYTE  relnote;          /* (byte) Relative note number (signed byte) */
  85.     UBYTE reserved;         /* (byte) Reserved */
  86.     char  samplename[22];   /* (char) Sample name */
  87. } XMWAVHEADER;
  88.  
  89.  
  90. typedef struct XMPATHEADER{
  91.     ULONG size;                             /* (dword) Pattern header length */
  92.     UBYTE packing;                  /* (byte) Packing type (always 0) */
  93.     UWORD numrows;                  /* (word) Number of rows in pattern (1..256) */
  94.     UWORD packsize;                 /* (word) Packed patterndata size */
  95. } XMPATHEADER;
  96.  
  97. typedef struct MTMNOTE{
  98.     UBYTE a,b,c;
  99. } MTMNOTE;
  100.  
  101.  
  102. typedef struct XMNOTE{
  103.     UBYTE note,ins,vol,eff,dat;
  104. }XMNOTE;
  105.  
  106. XMNOTE *xmpat;
  107.  
  108. /**************************************************************************
  109. **************************************************************************/
  110.  
  111.  
  112.  
  113. static XMHEADER *mh;
  114.  
  115. char XM_Version[]="XM";
  116.  
  117.  
  118.  
  119. BOOL XM_Test(void)
  120. {
  121.     char id[17];
  122.     if(!fread(id,17,1,modfp)) return 0;
  123.     if(!memcmp(id,"Extended Module: ",17)) return 1;
  124.     return 0;
  125. }
  126.  
  127.  
  128. BOOL XM_Init(void)
  129. {
  130.     mh=NULL;
  131.     if(!(mh=(XMHEADER *)MyCalloc(1,sizeof(XMHEADER)))) return 0;
  132.     return 1;
  133. }
  134.  
  135.  
  136. void XM_Cleanup(void)
  137. {
  138.     if(mh!=NULL) free(mh);
  139. }
  140.  
  141.  
  142. void XM_ReadNote(XMNOTE *n)
  143. {
  144.     UBYTE cmp;
  145.     memset(n,0,sizeof(XMNOTE));
  146.  
  147.     cmp=fgetc(modfp);
  148.  
  149.     if(cmp&0x80){
  150.         if(cmp&1) n->note=fgetc(modfp);
  151.         if(cmp&2) n->ins=fgetc(modfp);
  152.         if(cmp&4) n->vol=fgetc(modfp);
  153.         if(cmp&8) n->eff=fgetc(modfp);
  154.         if(cmp&16) n->dat=fgetc(modfp);
  155.     }
  156.     else{
  157.         n->note=cmp;
  158.         n->ins=fgetc(modfp);
  159.         n->vol=fgetc(modfp);
  160.         n->eff=fgetc(modfp);
  161.         n->dat=fgetc(modfp);
  162.     }
  163. }
  164.  
  165.  
  166. UBYTE *XM_Convert(XMNOTE *xmtrack,UWORD rows)
  167. {
  168.     int t;
  169.     UBYTE note,ins,vol,eff,dat;
  170.  
  171.     UniReset();
  172.  
  173.     for(t=0;t<rows;t++){
  174.  
  175.         note=xmtrack->note;
  176.         ins=xmtrack->ins;
  177.         vol=xmtrack->vol;
  178.         eff=xmtrack->eff;
  179.         dat=xmtrack->dat;
  180.  
  181.                 if(note!=0) UniNote(note-1);
  182.  
  183.                 if(ins!=0) UniInstrument(ins-1);
  184.  
  185. /*              printf("Vol:%d\n",vol); */
  186.  
  187.         switch(vol>>4){
  188.  
  189.             case 0x6:                    /* volslide down */
  190.                 if(vol&0xf){
  191.                     UniWrite(UNI_XMEFFECTA);
  192.                     UniWrite(vol&0xf);
  193.                 }
  194.                 break;
  195.  
  196.             case 0x7:                    /* volslide up */
  197.                 if(vol&0xf){
  198.                     UniWrite(UNI_XMEFFECTA);
  199.                     UniWrite(vol<<4);
  200.                 }
  201.                 break;
  202.  
  203.             /* volume-row fine volume slide is compatible with protracker
  204.                EBx and EAx effects i.e. a zero nibble means DO NOT SLIDE, as
  205.                opposed to 'take the last sliding value'.
  206.             */
  207.  
  208.             case 0x8:                        /* finevol down */
  209.                 UniPTEffect(0xe,0xb0 | (vol&0xf));
  210.                 break;
  211.  
  212.             case 0x9:                       /* finevol up */
  213.                 UniPTEffect(0xe,0xa0 | (vol&0xf));
  214.                 break;
  215.  
  216.             case 0xa:                       /* set vibrato speed */
  217.                 UniPTEffect(0x4,vol<<4);
  218.                 break;
  219.  
  220.             case 0xb:                       /* vibrato */
  221.                 UniPTEffect(0x4,vol&0xf);
  222.                 break;
  223.  
  224.             case 0xc:                       /* set panning */
  225.                 UniPTEffect(0x8,vol<<4);
  226.                 break;
  227.  
  228.             case 0xd:                       /* panning slide left */
  229.                 /* only slide when data nibble not zero: */
  230.  
  231.                 if(vol&0xf){
  232.                     UniWrite(UNI_XMEFFECTP);
  233.                     UniWrite(vol&0xf);
  234.                 }
  235.                 break;
  236.  
  237.             case 0xe:                       /* panning slide right */
  238.                 /* only slide when data nibble not zero: */
  239.  
  240.                 if(vol&0xf){
  241.                     UniWrite(UNI_XMEFFECTP);
  242.                     UniWrite(vol<<4);
  243.                 }
  244.                 break;
  245.  
  246.             case 0xf:                       /* tone porta */
  247.                 UniPTEffect(0x3,vol<<4);
  248.                 break;
  249.  
  250.             default:
  251.                 if(vol>=0x10 && vol<=0x50){
  252.                     UniPTEffect(0xc,vol-0x10);
  253.                 }
  254.         }
  255.  
  256. /*              if(eff>0xf) printf("Effect %d",eff); */
  257.  
  258.         switch(eff){
  259.  
  260.             case 'G'-55:                    /* G - set global volume */
  261.                 if(dat>64) dat=64;
  262.                 UniWrite(UNI_XMEFFECTG);
  263.                 UniWrite(dat);
  264.                 break;
  265.  
  266.             case 'H'-55:                    /* H - global volume slide */
  267.                 UniWrite(UNI_XMEFFECTH);
  268.                 UniWrite(dat);
  269.                 break;
  270.  
  271.             case 'K'-55:                    /* K - keyoff */
  272.                 UniNote(96);
  273.                 break;
  274.  
  275.             case 'L'-55:                    /* L - set envelope position */
  276.                 break;
  277.  
  278.             case 'P'-55:                    /* P - panning slide */
  279.                 UniWrite(UNI_XMEFFECTP);
  280.                 UniWrite(dat);
  281.                 break;
  282.  
  283.             case 'R'-55:                    /* R - multi retrig note */
  284.                 UniWrite(UNI_S3MEFFECTQ);
  285.                 UniWrite(dat);
  286.                 break;
  287.  
  288.             case 'T'-55:                     /* T - Tremor !! (== S3M effect I) */
  289.                 UniWrite(UNI_S3MEFFECTI);
  290.                 UniWrite(dat);
  291.                 break;
  292.  
  293.             case 'X'-55:
  294.                 if((dat>>4)==1){                /* X1 extra fine porta up */
  295.  
  296.  
  297.                 }
  298.                 else{                                   /* X2 extra fine porta down */
  299.  
  300.                 }
  301.                 break;
  302.  
  303.             default:
  304.                 if(eff==0xa){
  305.                     UniWrite(UNI_XMEFFECTA);
  306.                     UniWrite(dat);
  307.                 }
  308.                 else if(eff<=0xf) UniPTEffect(eff,dat);
  309.                 break;
  310.         }
  311.  
  312.         UniNewline();
  313.         xmtrack++;
  314.     }
  315.     return UniDup();
  316. }
  317.  
  318.  
  319.  
  320. BOOL XM_Load(void)
  321. {
  322.     INSTRUMENT *d;
  323.     SAMPLE *q;
  324.     int t,u,v,p,numtrk;
  325.     long next;
  326.  
  327.     /* try to read module header */
  328.  
  329.     _mm_read_str(mh->id,17,modfp);
  330.     _mm_read_str(mh->songname,21,modfp);
  331.     _mm_read_str(mh->trackername,20,modfp);
  332.     mh->version        =_mm_read_I_UWORD(modfp);
  333.     mh->headersize    =_mm_read_I_ULONG(modfp);
  334.     mh->songlength    =_mm_read_I_UWORD(modfp);
  335.     mh->restart        =_mm_read_I_UWORD(modfp);
  336.     mh->numchn        =_mm_read_I_UWORD(modfp);
  337.     mh->numpat        =_mm_read_I_UWORD(modfp);
  338.     mh->numins        =_mm_read_I_UWORD(modfp);
  339.     mh->flags        =_mm_read_I_UWORD(modfp);
  340.     mh->tempo        =_mm_read_I_UWORD(modfp);
  341.     mh->bpm            =_mm_read_I_UWORD(modfp);
  342.     _mm_read_UBYTES(mh->orders,256,modfp);
  343.  
  344.     if(feof(modfp)){
  345.         myerr = ERROR_LOADING_HEADER;
  346.         return 0;
  347.     }
  348.  
  349.     /* set module variables */
  350.  
  351.     of.initspeed=mh->tempo;
  352.     of.inittempo=mh->bpm;
  353.     of.modtype=DupStr(mh->trackername,20);
  354.     of.numchn=mh->numchn;
  355.     of.numpat=mh->numpat;
  356.     of.numtrk=(UWORD)of.numpat*of.numchn;   /* get number of channels */
  357.     of.songname=DupStr(mh->songname,20);    /* make a cstr of songname */
  358.     of.numpos=mh->songlength;                       /* copy the songlength */
  359.     of.reppos=mh->restart;
  360.     of.numins=mh->numins;
  361.     of.flags|=UF_XMPERIODS;
  362.     if(mh->flags&1) of.flags|=UF_LINEAR;
  363.  
  364.     memcpy(of.positions,mh->orders,256);
  365.  
  366. /*
  367.         WHY THIS CODE HERE?? I CAN'T REMEMBER!
  368.  
  369.         of.numpat=0;
  370.     for(t=0;t<of.numpos;t++){
  371.         if(of.positions[t]>of.numpat) of.numpat=of.positions[t];
  372.     }
  373.     of.numpat++;
  374. */
  375.  
  376. /*    printf("Modtype :%s\n",of.modtype);
  377.     printf("Version :%x\n",mh->version);
  378.     printf("Song    :%s\n",of.songname);
  379.     printf("Speed   :%d,%d\n",of.initspeed,of.inittempo);
  380.     printf("Channels:%d\n",of.numchn);
  381.     printf("Numins  :%d\n",mh->numins);
  382. */
  383.     if(!AllocTracks()) return 0;
  384.     if(!AllocPatterns()) return 0;
  385.  
  386.     numtrk=0;
  387.     for(t=0;t<mh->numpat;t++){
  388.         XMPATHEADER ph;
  389.  
  390. /*        printf("Reading pattern %d\n",t); */
  391.  
  392.         ph.size        =_mm_read_I_ULONG(modfp);
  393.         ph.packing    =_mm_read_UBYTE(modfp);
  394.         ph.numrows    =_mm_read_I_UWORD(modfp);
  395.         ph.packsize    =_mm_read_I_UWORD(modfp);
  396.  
  397. /*        printf("headln:  %ld\n",ph.size); */
  398. /*        printf("numrows: %d\n",ph.numrows); */
  399. /*        printf("packsize:%d\n",ph.packsize); */
  400.  
  401.                 of.pattrows[t]=ph.numrows;
  402.  
  403.         /*
  404.             Gr8.. when packsize is 0, don't try to load a pattern.. it's empty.
  405.             This bug was discovered thanks to Khyron's module..
  406.         */
  407.  
  408.         if(!(xmpat=(XMNOTE *)MyCalloc(ph.numrows*of.numchn,sizeof(XMNOTE)))) return 0;
  409.  
  410.         if(ph.packsize>0){
  411.             for(u=0;u<ph.numrows;u++){
  412.                 for(v=0;v<of.numchn;v++){
  413.                     XM_ReadNote(&xmpat[(v*ph.numrows)+u]);
  414.                 }
  415.             }
  416.         }
  417.  
  418.         for(v=0;v<of.numchn;v++){
  419.             of.tracks[numtrk++]=XM_Convert(&xmpat[v*ph.numrows],ph.numrows);
  420.         }
  421.  
  422.         free(xmpat);
  423.     }
  424.  
  425.     if(!AllocInstruments()) return 0;
  426.  
  427.     d=of.instruments;
  428.  
  429.     for(t=0;t<of.numins;t++){
  430.         XMINSTHEADER ih;
  431.  
  432.         /* read instrument header */
  433.  
  434.         ih.size        =_mm_read_I_ULONG(modfp);
  435.         _mm_read_str (ih.name, 22, modfp);
  436.         ih.type        =_mm_read_UBYTE(modfp);
  437.         ih.numsmp    =_mm_read_I_UWORD(modfp);
  438.         ih.ssize    =_mm_read_I_ULONG(modfp);
  439.  
  440. /*      printf("Size: %ld\n",ih.size);
  441.         printf("Name:     %22.22s\n",ih.name);
  442.         printf("Samples:%d\n",ih.numsmp);
  443.         printf("sampleheadersize:%ld\n",ih.ssize);
  444. */
  445.         d->insname=DupStr(ih.name,22);
  446.         d->numsmp=ih.numsmp;
  447.  
  448.         if(!AllocSamples(d)) return 0;
  449.  
  450.         if(ih.numsmp>0){
  451.             XMPATCHHEADER pth;
  452.             XMWAVHEADER wh;
  453.  
  454.             _mm_read_UBYTES (pth.what, 96, modfp);
  455.             _mm_read_UBYTES (pth.volenv, 48, modfp);
  456.             _mm_read_UBYTES (pth.panenv, 48, modfp);
  457.             pth.volpts        =_mm_read_UBYTE(modfp);
  458.             pth.panpts        =_mm_read_UBYTE(modfp);
  459.             pth.volsus        =_mm_read_UBYTE(modfp);
  460.             pth.volbeg        =_mm_read_UBYTE(modfp);
  461.             pth.volend        =_mm_read_UBYTE(modfp);
  462.             pth.pansus        =_mm_read_UBYTE(modfp);
  463.             pth.panbeg        =_mm_read_UBYTE(modfp);
  464.             pth.panend        =_mm_read_UBYTE(modfp);
  465.             pth.volflg        =_mm_read_UBYTE(modfp);
  466.             pth.panflg        =_mm_read_UBYTE(modfp);
  467.             pth.vibflg        =_mm_read_UBYTE(modfp);
  468.             pth.vibsweep    =_mm_read_UBYTE(modfp);
  469.             pth.vibdepth    =_mm_read_UBYTE(modfp);
  470.             pth.vibrate        =_mm_read_UBYTE(modfp);
  471.             pth.volfade        =_mm_read_I_UWORD(modfp);
  472.             _mm_read_I_UWORDS(pth.reserved, 11, modfp);
  473.  
  474.             memcpy(d->samplenumber,pth.what,96);
  475.  
  476.             d->volfade=pth.volfade;
  477.  
  478. /*            printf("Volfade %x\n",d->volfade); */
  479.  
  480.             memcpy(d->volenv,pth.volenv,24);
  481.             d->volflg=pth.volflg;
  482.             d->volsus=pth.volsus;
  483.             d->volbeg=pth.volbeg;
  484.             d->volend=pth.volend;
  485.             d->volpts=pth.volpts;
  486.  
  487. /*            printf("volume points    : %d\n"
  488.                    "volflg            : %d\n"
  489.                    "volbeg            : %d\n"
  490.                    "volend            : %d\n"
  491.                    "volsus            : %d\n",
  492.                    d->volpts,
  493.                    d->volflg,
  494.                    d->volbeg,
  495.                    d->volend,
  496.                    d->volsus);
  497. */
  498.             /* scale volume envelope: */
  499.  
  500.             for(p=0;p<12;p++){
  501.                 d->volenv[p].val<<=2;
  502. /*                printf("%d,%d,",d->volenv[p].pos,d->volenv[p].val); */
  503.             }
  504.  
  505.             memcpy(d->panenv,pth.panenv,24);
  506.             d->panflg=pth.panflg;
  507.             d->pansus=pth.pansus;
  508.             d->panbeg=pth.panbeg;
  509.             d->panend=pth.panend;
  510.             d->panpts=pth.panpts;
  511.  
  512. /*                      printf("Panning points    : %d\n"
  513.                    "panflg            : %d\n"
  514.                    "panbeg            : %d\n"
  515.                    "panend            : %d\n"
  516.                    "pansus            : %d\n",
  517.                    d->panpts,
  518.                    d->panflg,
  519.                    d->panbeg,
  520.                    d->panend,
  521.                    d->pansus);
  522. */
  523.             /* scale panning envelope: */
  524.  
  525.             for(p=0;p<12;p++){
  526.                 d->panenv[p].val<<=2;
  527. /*                printf("%d,%d,",d->panenv[p].pos,d->panenv[p].val); */
  528.             }
  529.  
  530. /*                      for(u=0;u<256;u++){ */
  531. /*                              printf("%2.2x ",fgetc(modfp)); */
  532. /*                      } */
  533.  
  534.             next=0;
  535.  
  536.             for(u=0;u<ih.numsmp;u++){
  537.                 q=&d->samples[u];
  538.  
  539.                 wh.length        =_mm_read_I_ULONG (modfp);
  540.                 wh.loopstart    =_mm_read_I_ULONG (modfp);
  541.                 wh.looplength    =_mm_read_I_ULONG (modfp);
  542.                 wh.volume        =_mm_read_UBYTE (modfp);
  543.                 wh.finetune        =_mm_read_SBYTE (modfp);
  544.                 wh.type            =_mm_read_UBYTE (modfp);
  545.                 wh.panning        =_mm_read_UBYTE (modfp);
  546.                 wh.relnote        =_mm_read_SBYTE (modfp);
  547.                 wh.reserved        =_mm_read_UBYTE (modfp);
  548.                 _mm_read_str(wh.samplename, 22, modfp);
  549.  
  550. /*              printf("wav %d:%22.22s\n",u,wh.samplename); */
  551.  
  552.                 q->samplename   =DupStr(wh.samplename,22);
  553.                 q->length       =wh.length;
  554.                 q->loopstart    =wh.loopstart;
  555.                 q->loopend      =wh.loopstart+wh.looplength;
  556.                 q->volume       =wh.volume;
  557.                 q->c2spd        =wh.finetune+128;
  558.                 q->transpose    =wh.relnote;
  559.                 q->panning      =wh.panning;
  560.                 q->seekpos        =next;
  561.  
  562.                 if(wh.type&0x10){
  563.                     q->length>>=1;
  564.                     q->loopstart>>=1;
  565.                     q->loopend>>=1;
  566.                 }
  567.  
  568.                 next+=wh.length;
  569.  
  570. /*                              printf("Type %u\n",wh.type); */
  571. /*                printf("Trans %d\n",wh.relnote); */
  572.  
  573.                 q->flags|=SF_OWNPAN;
  574.                 if(wh.type&0x3) q->flags|=SF_LOOP;
  575.                 if(wh.type&0x2) q->flags|=SF_BIDI;
  576.  
  577.                 if(wh.type&0x10) q->flags|=SF_16BITS;
  578.                 q->flags|=SF_DELTA;
  579.                 q->flags|=SF_SIGNED;
  580.             }
  581.  
  582.             for(u=0;u<ih.numsmp;u++) d->samples[u].seekpos+=_mm_ftell(modfp);
  583.  
  584.             _mm_fseek(modfp,next,SEEK_CUR);
  585.         }
  586.  
  587.         d++;
  588.     }
  589.  
  590.  
  591.     return 1;
  592. }
  593.  
  594.  
  595. LOADER load_xm={
  596.     NULL,
  597.     "XM",
  598.     "Portable XM loader v0.4 - for your ears only / MikMak",
  599.     XM_Init,
  600.     XM_Test,
  601.     XM_Load,
  602.     XM_Cleanup
  603. };
  604.