void Depack_Polka ( void )
{
Uchar poss[37][2];
Uchar c1=0x00,c2=0x00;
Uchar Max=0x00;
long WholeSampleSize=0;
long i=0,j;
long Where = PW_Start_Address;
FILE *out;
unsigned char Whatever[4];
if ( Save_Status == BAD )
return;
fillPTKtable(poss);
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* takes care of header */
fwrite ( &in_data[Where], 20, 1, out );
for ( i=0 ; i<31 ; i++ )
{
fwrite ( &in_data[Where+20+i*30], 18, 1, out );
c1=0x00;
fwrite ( &c1, 1, 1, out );fwrite ( &c1, 1, 1, out );
fwrite ( &c1, 1, 1, out );fwrite ( &c1, 1, 1, out );
fwrite ( &in_data[Where+42+i*30], 8, 1, out );
WholeSampleSize += (((in_data[Where+42+i*30]*256)+in_data[Where+43+i*30])*2);
}
/*printf ( "Whole sanple size : %ld\n" , WholeSampleSize );*/
/* read and write size of pattern list+ntk byte + pattern list */
fwrite ( &in_data[Where+0x3b6] , 130 , 1 , out );
/* write ID */
c1 = 'M';
c2 = '.';
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
c1 = 'K';
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
/* get number of pattern */
Max = 0x00;
for ( i=0 ; i<128 ; i++ )
{
if ( in_data[Where+i+0x3b8] > Max )
Max = in_data[Where+i+0x3b8];
}
Max += 1;
/*printf ( "\nNumber of pattern : %ld\n" , j );*/
/* pattern data */
Where = PW_Start_Address + 0x43c;
for ( i=0 ; i<Max ; i++ )
{
for ( j=0 ; j<256 ; j++ )
{
Whatever[0] = in_data[Where+1] & 0xf0;
Whatever[2] = (in_data[Where+1] & 0x0f)<<4;
Whatever[2] |= in_data[Where+2];
Whatever[3] = in_data[Where+3];
Whatever[0] |= poss[(in_data[Where])/2][0];
Whatever[1] = poss[(in_data[Where]/2)][1];
fwrite ( Whatever , 4 , 1 , out );
Where += 4;
}
}
/* sample data */
fwrite ( &in_data[Where] , WholeSampleSize , 1 , out );
/* crap */
Crap ( " Polka Packer " , BAD , BAD , out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_Fuzzac ( void )
{
Uchar c5;
Uchar PatPos;
Uchar *Whatever;
Uchar NbrTracks;
Uchar Track_Numbers[128][16];
Uchar Track_Numbers_Real[128][4];
Uchar Track_Datas[4][256];
Uchar Status=ON;
long WholeSampleSize=0;
long i,j,k,l;
long Where = PW_Start_Address;
FILE *out;
if ( Save_Status == BAD )
return;
BZERO ( Track_Numbers , 128*16 );
BZERO ( Track_Numbers_Real , 128*4 );
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* bypass ID */
/* bypass 2 unknown bytes */
Where += 6;
/* write title */
Whatever = (Uchar *) malloc (1024);
BZERO ( Whatever , 1024 );
fwrite ( Whatever , 20 , 1 , out );
/*printf ( "Converting header ... " );*/
/*fflush ( stdout );*/
for ( i=0 ; i<31 ; i++ )
{
/*sample name*/
fwrite ( &in_data[Where] , 22 , 1 , out );
WholeSampleSize += (((in_data[Where+60]*256)+in_data[Where+61])*2);
fwrite ( &in_data[Where+60] , 2 , 1 , out );
fwrite ( &in_data[Where+66] , 2 , 1 , out );
fwrite ( &in_data[Where+62] , 2 , 1 , out );
Whatever[0] = in_data[Where+65];
if ( (in_data[Where+64]==0x00) && (in_data[Where+65]==0x00) )
Whatever[0] = 0x01;
fwrite ( &in_data[Where+64] , 1 , 1 , out );
fwrite ( Whatever , 1 , 1 , out );
Where += 68;
}
/*printf ( "ok\n" );*/
/*printf ( " - Whole sample size : %ld\n" , WholeSampleSize );*/
/* read & write size of pattern list */
PatPos = in_data[Where++];
fwrite ( &PatPos , 1 , 1 , out );
/*printf ( " - size of pattern list : %d\n" , PatPos );*/
/* read the number of tracks */
NbrTracks = in_data[Where++];
/* write noisetracker byte */
Whatever[0] = 0x7f;
fwrite ( Whatever , 1 , 1 , out );
/* place file pointer at track number list address */
Where = PW_Start_Address + 2118;
/* read tracks numbers */
for ( i=0 ; i<4 ; i++ )
{
for ( j=0 ; j<PatPos ; j++ )
{
Track_Numbers[j][i*4] = in_data[Where++];
Track_Numbers[j][i*4+1] = in_data[Where++];
Track_Numbers[j][i*4+2] = in_data[Where++];
Track_Numbers[j][i*4+3] = in_data[Where++];
}
}
/* sort tracks numbers */
c5 = 0x00;
for ( i=0 ; i<PatPos ; i++ )
{
if ( i == 0 )
{
Whatever[0] = c5;
c5 += 0x01;
continue;
}
for ( j=0 ; j<i ; j++ )
{
Status = ON;
for ( k=0 ; k<4 ; k++ )
{
if ( Track_Numbers[j][k*4] != Track_Numbers[i][k*4] )
{
Status=OFF;
break;
}
}
if ( Status == ON )
{
Whatever[i] = Whatever[j];
break;
}
}
if ( Status == OFF )
{
Whatever[i] = c5;
c5 += 0x01;
}
Status = ON;
}
/* c5 is the Max pattern number */
/* create a real list of tracks numbers for the really existing patterns */
Whatever[129] = 0x00;
for ( i=0 ; i<PatPos ; i++ )
{
if ( i==0 )
{
Track_Numbers_Real[Whatever[129]][0] = Track_Numbers[i][0];
Track_Numbers_Real[Whatever[129]][1] = Track_Numbers[i][4];
Track_Numbers_Real[Whatever[129]][2] = Track_Numbers[i][8];
Track_Numbers_Real[Whatever[129]][3] = Track_Numbers[i][12];
Whatever[129] += 0x01;
continue;
}
for ( j=0 ; j<i ; j++ )
{
Status = ON;
if ( Whatever[i] == Whatever[j] )
{
Status = OFF;
break;
}
}
if ( Status == OFF )
continue;
Track_Numbers_Real[Whatever[129]][0] = Track_Numbers[i][0];
Track_Numbers_Real[Whatever[129]][1] = Track_Numbers[i][4];
Track_Numbers_Real[Whatever[129]][2] = Track_Numbers[i][8];
Track_Numbers_Real[Whatever[129]][3] = Track_Numbers[i][12];
Whatever[129] += 0x01;
Status = ON;
}
/* write pattern list */
fwrite ( Whatever , 128 , 1 , out );
/* write ID */
Whatever[0] = 'M';
Whatever[1] = '.';
Whatever[2] = 'K';
Whatever[3] = '.';
fwrite ( Whatever , 4 , 1 , out );
/* pattern data */
/*printf ( "Processing the pattern datas ... " );*/
/*fflush ( stdout );*/
l = PW_Start_Address + 2118 + (PatPos * 16);
for ( i=0 ; i<c5 ; i++ )
{
BZERO ( Whatever , 1024 );
BZERO ( Track_Datas , 4*256 );
Where = l + (Track_Numbers_Real[i][0]*256);
for ( j=0 ; j<256 ; j++ ) Track_Datas[0][j] = in_data[Where+j];
Where = l + (Track_Numbers_Real[i][1]*256);
for ( j=0 ; j<256 ; j++ ) Track_Datas[1][j] = in_data[Where+j];
Where = l + (Track_Numbers_Real[i][2]*256);
for ( j=0 ; j<256 ; j++ ) Track_Datas[2][j] = in_data[Where+j];
Where = l + (Track_Numbers_Real[i][3]*256);
for ( j=0 ; j<256 ; j++ ) Track_Datas[3][j] = in_data[Where+j];
for ( j=0 ; j<64 ; j++ )
{
Whatever[j*16] = Track_Datas[0][j*4];
Whatever[j*16+1] = Track_Datas[0][j*4+1];
Whatever[j*16+2] = Track_Datas[0][j*4+2];
Whatever[j*16+3] = Track_Datas[0][j*4+3];
Whatever[j*16+4] = Track_Datas[1][j*4];
Whatever[j*16+5] = Track_Datas[1][j*4+1];
Whatever[j*16+6] = Track_Datas[1][j*4+2];
Whatever[j*16+7] = Track_Datas[1][j*4+3];
Whatever[j*16+8] = Track_Datas[2][j*4];
Whatever[j*16+9] = Track_Datas[2][j*4+1];
Whatever[j*16+10] = Track_Datas[2][j*4+2];
Whatever[j*16+11] = Track_Datas[2][j*4+3];
Whatever[j*16+12] = Track_Datas[3][j*4];
Whatever[j*16+13] = Track_Datas[3][j*4+1];
Whatever[j*16+14] = Track_Datas[3][j*4+2];
Whatever[j*16+15] = Track_Datas[3][j*4+3];
}
fwrite ( Whatever , 1024 , 1 , out );
/*printf ( "+" );*/
/*fflush ( stdout );*/
}
free ( Whatever );
/*printf ( "ok\n" );*/
/* sample data */
/*printf ( "Saving sample data ... " );*/
/*fflush ( stdout );*/
Where = l + 4 + NbrTracks*256;
/* l : 2118 + NumberOfPattern*16+PW_Start_Address */
/* 4 : to bypass the "SEnd" unidentified ID */
fwrite ( &in_data[Where] , WholeSampleSize , 1 , out );
/*printf ( "ok\n" );*/
/* crap ... */
Crap ( " FUZZAC Packer " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_PP30 ( void )
{
Uchar *Header, *Pattern;
Ulong ReadTrkPat[128][4], ReadPat[128];
long Highest_Track = 0;
long whereTableRef;
long i=0,j=0,k=0,l=0,m=0;
long Total_Sample_Size=0;
long Where=PW_Start_Address;
FILE *out;
if ( Save_Status == BAD )
return;
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
Header = (Uchar *)malloc(1084);
Pattern = (Uchar *)malloc(1024);
BZERO ( Header , 1084 );
BZERO ( Pattern , 1024 );
for ( i=0 ; i<31 ; i++ )
{
Total_Sample_Size += (((in_data[Where]*256)+in_data[Where+1])*2);
/* siz,fine,vol,lstart,lsize */
Header[42+i*30] = in_data[Where];
Header[43+i*30] = in_data[Where+1];
Header[44+i*30] = in_data[Where+2];
Header[45+i*30] = in_data[Where+3];
Header[46+i*30] = in_data[Where+4];
Header[47+i*30] = in_data[Where+5];
Header[48+i*30] = in_data[Where+6];
Header[49+i*30] = in_data[Where+7];
Where += 8;
}
/* pattern table lenght */
Header[950] = in_data[Where];
Where += 1;
/*printf ( "Number of patterns : %d\n" , Header[950] );*/
/* NoiseTracker restart byte */
Header[951] = in_data[Where];
Where += 1;
/* now, where = 0xFA */
for (i=0;i<Header[950];i++)
{
ReadPat[i] = (in_data[Where+i]*256*256*256) +
(in_data[Where+i+128]*256*256) +
(in_data[Where+i+256]*256) +
in_data[Where+i+384];
ReadTrkPat[i][0] = in_data[Where+i];
ReadTrkPat[i][1] = in_data[Where+i+128];
ReadTrkPat[i][2] = in_data[Where+i+256];
ReadTrkPat[i][3] = in_data[Where+i+384];
if (ReadTrkPat[i][0] > Highest_Track)
Highest_Track = ReadTrkPat[i][0];
if (ReadTrkPat[i][1] > Highest_Track)
Highest_Track = ReadTrkPat[i][1];
if (ReadTrkPat[i][2] > Highest_Track)
Highest_Track = ReadTrkPat[i][2];
if (ReadTrkPat[i][3] > Highest_Track)
Highest_Track = ReadTrkPat[i][3];
/*printf ("%x-%x-%x-%x\n",ReadTrkPat[i][0],ReadTrkPat[i][1],ReadTrkPat[i][2],ReadTrkPat[i][3]);*/
}
/*printf ( "Number of tracks : %d\n" , Highest_Track+1 );*/
/* sorting ?*/
k = 0; /* next min */
l = 0;
/* put the first pattern number */
/* could be stored several times */
for (j=0; j<Header[950] ; j++)
{
m = 0x7fffffff; /* min */
/*search for min */
for (i=0; i<Header[950] ; i++)
if ((ReadPat[i]<m) && (ReadPat[i]>k))
m = ReadPat[i];
/* if k == m then an already existing ref was found */
if (k==m)
continue;
/* m is the next minimum */
k = m;
for (i=0; i<Header[950] ; i++)
if (ReadPat[i] == k)
{
Header[952+i] = (unsigned char)l;
j++;
}
j--;
l++;
}
/* write ptk's ID */
Header[1080] = 'M';
Header[1081] = Header[1083] = '.';
Header[1082] = 'K';
fwrite (Header, 1084, 1, out);
/* put 'where' at track data level - after track list */
Where = PW_Start_Address + 762;
/* rebuild patterns now */
/* l is the number of stored patterns */
/* rebuild pattern data now */
whereTableRef = ((Highest_Track + 1)*128) + 4 + Where;
/*printf ( "\nwhereTableRef : %ld\n",whereTableRef);*/
for (i=0;i<l;i++)
{
BZERO(Pattern,1024);
/* which pattern is it now ? */
for (j=0;j<Header[950];j++)
{
if (Header[952+j] == i)
break; /* found */
}
for (k=0;k<4;k++) /* loop on 4 tracks' refs*/
{
long d;
/* loop on notes */
for (d=0;d<64;d++)
{
/* read one ref value to be fetch in the reference table */
long val = (in_data[Where+(ReadTrkPat[j][k]*128)+(d*2)])*256
+ in_data[Where+(ReadTrkPat[j][k]*128)+(d*2)+1];
Pattern[k*4+d*16] = in_data[whereTableRef + val];
Pattern[k*4+d*16+1] = in_data[whereTableRef + val + 1];
Pattern[k*4+d*16+2] = in_data[whereTableRef + val + 2];
Pattern[k*4+d*16+3] = in_data[whereTableRef + val + 3];
}
}
fwrite ( Pattern , 1024 , 1 , out );
}
free ( Pattern );
free ( Header );
/* locate sample start addy - after reference table */
j = ((in_data[whereTableRef-4]*256*256*256)+
(in_data[whereTableRef-3]*256*256)+
(in_data[whereTableRef-2]*256)+
in_data[whereTableRef-1]);
/*printf ( "\nj:%ld - Where:%ld\n",j,Where );*/
/* sample data */
fwrite ( &in_data[j+whereTableRef] , Total_Sample_Size , 1 , out );
Crap ( " ProPacker v3.0 " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_EUREKA ( void )
{
Uchar *Whatever;
Uchar c1=0x00;
Uchar Pat_Max=0x00;
long Sample_Start_Address=0;
long WholeSampleSize=0;
long Track_Address[128][4];
long i=0,j=0,k;
long Where = PW_Start_Address;
FILE *out;
if ( Save_Status == BAD )
return;
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* read header ... same as ptk */
fwrite ( &in_data[Where] , 1080 , 1 , out );
/* now, let's sort out that a bit :) */
/* first, the whole sample size */
for ( i=0 ; i<31 ; i++ )
WholeSampleSize += (((in_data[Where+i*30+42]*256)+in_data[Where+i*30+43])*2);
/*printf ( "Whole sample size : %ld\n" , WholeSampleSize );*/
/* next, the size of the pattern list */
/*printf ( "Size of pattern list : %d\n" , in_data[Where+950] );*/
/* now, the pattern list .. and the max */
Pat_Max = 0x00;
for ( i=0 ; i<128 ; i++ )
{
if ( in_data[Where+952+i] > Pat_Max )
Pat_Max = in_data[Where+952+i];
}
Pat_Max += 1;
/*printf ( "Number of patterns : %d\n" , Pat_Max );*/
/* write ptk's ID */
Whatever = (Uchar *) malloc (1024);
BZERO ( Whatever , 1024 );
Whatever[0] = 'M';
Whatever[1] = '.';
Whatever[2] = 'K';
Whatever[3] = '.';
fwrite ( Whatever , 4 , 1 , out );
/* read sample data address */
Where = PW_Start_Address+1080;
Sample_Start_Address = (in_data[Where]*256*256*256)+
(in_data[Where+1]*256*256)+
(in_data[Where+2]*256)+
in_data[Where+3];
Where += 4;
/*printf ( "Address of sample data : %ld\n" , Sample_Start_Address );*/
/* read tracks addresses */
for ( i=0 ; i<Pat_Max ; i++ )
{
for ( j=0 ; j<4 ; j++ )
{
Track_Address[i][j] = (in_data[Where]*256)+in_data[Where+1];
Where += 2;
}
}
/* the track data now ... */
for ( i=0 ; i<Pat_Max ; i++ )
{
BZERO ( Whatever , 1024 );
for ( j=0 ; j<4 ; j++ )
{
Where = PW_Start_Address + Track_Address[i][j];
for ( k=0 ; k<64 ; k++ )
{
c1 = in_data[Where++];
if ( ( c1 & 0xc0 ) == 0x00 )
{
Whatever[k*16+j*4] = c1;
Whatever[k*16+j*4+1] = in_data[Where++];
Whatever[k*16+j*4+2] = in_data[Where++];
Whatever[k*16+j*4+3] = in_data[Where++];
continue;
}
if ( ( c1 & 0xc0 ) == 0xc0 )
{
k += (c1&0x3f);
continue;
}
if ( ( c1 & 0xc0 ) == 0x40 )
{
Whatever[k*16+j*4+2] = c1&0x0f;
Whatever[k*16+j*4+3] = in_data[Where++];
continue;
}
if ( ( c1 & 0xc0 ) == 0x80 )
{
Whatever[k*16+j*4] = in_data[Where++];
Whatever[k*16+j*4+1] = in_data[Where++];
Whatever[k*16+j*4+2] = (c1<<4)&0xf0;
continue;
}
}
}
fwrite ( Whatever , 1024 , 1 , out );
/*printf ( "+" );*/
}
free ( Whatever );
/* go to sample data addy */
Where = PW_Start_Address + Sample_Start_Address;
/* read sample data */
fwrite ( &in_data[Where] , WholeSampleSize , 1 , out );
/* crap .. */
Crap ( " EUREKA Packer " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_SoundFX13 (FILE * in, FILE * out)
{
uint8 *tmp;
uint8 c0 = 0x00, c1 = 0x00, c2 = 0x00, c3 = 0x00;
uint8 Max = 0x00;
uint8 PatPos;
long ssize = 0;
long i = 0, j = 0;
// FILE *in,*out;
if (Save_Status == BAD)
return;
// in = fdopen (fd_in, "rb");
// sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
// out = fdopen (fd_out, "w+b");
/* title */
tmp = (uint8 *) malloc (20);
memset(tmp, 0, 20);
fwrite (tmp, 20, 1, out);
free (tmp);
/* read and write whole header */
for (i = 0; i < 15; i++) {
fseek (in, 0x50 + i * 30, 0);
/* write name */
for (j = 0; j < 22; j++) {
xmp_fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
}
/* size */
fseek (in, i * 4 + 1, 0);
xmp_fread (&c0, 1, 1, in);
xmp_fread (&c1, 1, 1, in);
xmp_fread (&c2, 1, 1, in);
c2 /= 2;
c3 = c1 / 2;
if ((c3 * 2) != c1)
c2 += 0x80;
if (c0 != 0x00)
c3 += 0x80;
fseek (in, 0x50 + i * 30 + 24, 0);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
ssize += (((c3 << 8) + c2) * 2);
/* finetune */
xmp_fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
/* volume */
xmp_fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
/* loop start */
xmp_fread (&c1, 1, 1, in);
xmp_fread (&c2, 1, 1, in);
c2 /= 2;
c3 = c1 / 2;
if ((c3 * 2) != c1)
c2 += 0x80;
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* loop size */
xmp_fread (&c1, 1, 1, in);
xmp_fread (&c2, 1, 1, in);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
}
tmp = (uint8 *) malloc (30);
memset(tmp, 0, 30);
tmp[29] = 0x01;
for (i = 0; i < 16; i++)
fwrite (tmp, 30, 1, out);
free (tmp);
/* pattern list size */
xmp_fread (&PatPos, 1, 1, in);
fwrite (&PatPos, 1, 1, out);
/* ntk byte */
fseek (in, 1, 1);
c1 = 0x7f;
fwrite (&c1, 1, 1, out);
/* read and write pattern list */
Max = 0x00;
for (i = 0; i < PatPos; i++) {
xmp_fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
if (c1 > Max)
Max = c1;
}
c1 = 0x00;
while (i != 128) {
fwrite (&c1, 1, 1, out);
i += 1;
}
/* write ID */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* pattern data */
fseek (in, 0x294, 0);
tmp = (uint8 *) malloc (1024);
for (i = 0; i <= Max; i++) {
memset(tmp, 0, 1024);
xmp_fread (tmp, 1024, 1, in);
for (j = 0; j < 256; j++) {
if (tmp[(j * 4)] == 0xff) {
if (tmp[(j * 4) + 1] != 0xfe)
printf
("Volume unknown : (at:%ld) (fx:%x,%x,%x,%x)\n",
ftell (in)
, tmp[(j * 4)]
, tmp[(j * 4) + 1]
, tmp[(j * 4) + 2]
, tmp[(j * 4) + 3]);
tmp[(j * 4)] = 0x00;
tmp[(j * 4) + 1] = 0x00;
tmp[(j * 4) + 2] = 0x0C;
tmp[(j * 4) + 3] = 0x00;
continue;
}
switch (tmp[(j * 4) + 2] & 0x0f) {
case 1: /* arpeggio */
tmp[(j * 4) + 2] &= 0xF0;
break;
case 7: /* slide up */
case 8: /* slide down */
tmp[(j * 4) + 2] -= 0x06;
break;
case 3: /* empty ... same as followings ... but far too much to "printf" it */
case 6: /* and Noiseconverter puts 00 instead ... */
tmp[(j * 4) + 2] &= 0xF0;
tmp[(j * 4) + 3] = 0x00;
break;
case 2:
case 4:
case 5:
case 9:
case 0x0a:
case 0x0b:
case 0x0c:
case 0x0d:
case 0x0e:
case 0x0f:
printf
("unsupported effect : (at:%ld) (fx:%d)\n",
ftell (in),
tmp[(j * 4) + 2] & 0x0f);
tmp[(j * 4) + 2] &= 0xF0;
tmp[(j * 4) + 3] = 0x00;
break;
default:
break;
}
}
fwrite (tmp, 1024, 1, out);
fflush (stdout);
}
free (tmp);
fflush (stdout);
/* sample data */
tmp = (uint8 *) malloc (ssize);
memset(tmp, 0, ssize);
xmp_fread (tmp, ssize, 1, in);
fwrite (tmp, ssize, 1, out);
free (tmp);
fflush (stdout);
/* crap */
Crap (" Sound FX ", BAD, BAD, out);
fflush (in);
fflush (out);
// fclose ( in );
// fclose ( out );
printf ("done\n"
" WARNING: This is only an under devellopment converter !\n"
" output could sound strange...\n");
return; /* useless ... but */
}
void Depack_PM20 (FILE * in, FILE * out)
{
uint8 c1 = 0x00, c2 = 0x00, c3 = 0x00, c4 = 0x00;
short pat_max = 0;
long tmp_ptr, tmp1, tmp2;
short refmax = 0;
uint8 pnum[128];
uint8 pnum_tmp[128];
long paddr[128];
long paddr_tmp[128];
long paddr_tmp2[128];
short pptr[64][256];
uint8 NOP = 0x00; /* number of pattern */
uint8 *reftab;
uint8 *sdata;
uint8 Pattern[128][1024];
long i = 0, j = 0, k = 0;
long ssize = 0;
long psize = 0l;
long SDAV = 0l;
uint8 FLAG = OFF;
uint8 ptk_table[37][2];
uint8 note, ins;
// FILE *in,*out;
if (Save_Status == BAD)
return;
#include "ptktable.h"
// in = fdopen (fd_in, "rb");
// sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
// out = fdopen (fd_out, "w+b");
memset(pnum, 0, 128);
memset(pnum_tmp, 0, 128);
memset(pptr, 0, 64 << 8);
memset(Pattern, 0, 128 * 1024);
memset(paddr, 0, 128 * 4);
memset(paddr_tmp, 0, 128 * 4);
for (i = 0; i < 128; i++)
paddr_tmp2[i] = 9999l;
for (i = 0; i < 20; i++) /* title */
fwrite (&c1, 1, 1, out);
/* bypass replaycode routine */
fseek (in, SAMPLE_DESC, 0); /* SEEK_SET */
for (i = 0; i < 31; i++) {
c1 = 0x00;
for (j = 0; j < 22; j++) /*sample name */
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* size */
fread (&c2, 1, 1, in);
ssize += (((c1 << 8) + c2) * 2);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fread (&c1, 1, 1, in); /* finetune */
c1 /= 2;
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* volume */
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* loop start */
fread (&c2, 1, 1, in);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fread (&c1, 1, 1, in); /* loop size */
fread (&c2, 1, 1, in);
if ((c1 == 0x00) && (c2 == 0x00))
c2 = 0x01;
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
}
/* read REAL number of pattern */
fseek (in, AFTER_REPLAY_CODE + 1, 0); /* SEEK_SET */
fread (&NOP, 1, 1, in);
/*printf ( "REAL Number of patterns : %d\n" , NOP ); */
/* read "used" size of pattern table */
fseek (in, 1, 1); /* SEEK_CUR */
fread (&c1, 1, 1, in);
c4 = c1 / 2;
/*printf ( "Number of pattern in pattern list : %d\n" , c4 ); */
/* write size of pattern list */
fwrite (&c4, 1, 1, out);
/* NoiseTracker restart byte */
c1 = 0x7f;
fwrite (&c1, 1, 1, out);
for (i = 0; i < 128; i++) {
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
paddr[i] = (c1 << 8) + c2;
}
/* ordering of patterns addresses */
/* c4 contains the size of the pattern list .. */
tmp_ptr = 0;
for (i = 0; i < c4; i++) {
if (i == 0) {
pnum[0] = 0x00;
tmp_ptr++;
continue;
}
for (j = 0; j < i; j++) {
if (paddr[i] == paddr[j]) {
pnum[i] = pnum[j];
break;
}
}
if (j == i)
pnum[i] = tmp_ptr++;
}
pat_max = tmp_ptr - 1;
/* correct re-order */
/********************/
for (i = 0; i < c4; i++)
paddr_tmp[i] = paddr[i];
restart:
for (i = 0; i < c4; i++) {
for (j = 0; j < i; j++) {
if (paddr_tmp[i] < paddr_tmp[j]) {
tmp2 = pnum[j];
pnum[j] = pnum[i];
pnum[i] = tmp2;
tmp1 = paddr_tmp[j];
paddr_tmp[j] = paddr_tmp[i];
paddr_tmp[i] = tmp1;
goto restart;
}
}
}
j = 0;
for (i = 0; i < c4; i++) {
if (i == 0) {
paddr_tmp2[j] = paddr_tmp[i];
continue;
}
if (paddr_tmp[i] == paddr_tmp2[j])
continue;
paddr_tmp2[++j] = paddr_tmp[i];
}
for (c1 = 0x00; c1 < c4; c1++) {
for (c2 = 0x00; c2 < c4; c2++)
if (paddr[c1] == paddr_tmp2[c2]) {
pnum_tmp[c1] = c2;
}
}
for (i = 0; i < c4; i++)
pnum[i] = pnum_tmp[i];
/* write pattern table */
for (c1 = 0x00; c1 < 128; c1++) {
fwrite (&pnum[c1], 1, 1, out);
}
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* a little pre-calc code ... no other way to deal with these unknown
pattern data sizes ! :( */
/* so, first, we get the pattern data size .. */
fseek (in, ADDRESS_REF_TABLE, 0); /* SEEK_SET */
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
fread (&c3, 1, 1, in);
fread (&c4, 1, 1, in);
j = (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
psize = (AFTER_REPLAY_CODE + j) - PATTERN_DATA;
/*printf ( "Pattern data size : %ld\n" , psize ); */
/* go back to pattern data starting address */
fseek (in, 5226, 0); /* SEEK_SET */
/* now, reading all pattern data to get the max value of note */
for (j = 0; j < psize; j += 2) {
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
if (((c1 << 8) + c2) > refmax)
refmax = (c1 << 8) + c2;
}
/*
printf ( "* refmax = %d\n" , refmax );
printf ( "* where : %ld\n" , ftell ( in ) );
*/
/* read "reference Table" */
fseek (in, ADDRESS_REF_TABLE, 0); /* SEEK_SET */
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
fread (&c3, 1, 1, in);
fread (&c4, 1, 1, in);
j = (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
fseek (in, AFTER_REPLAY_CODE + j, 0); /* SEEK_SET */
/*printf ( "address of 'reference table' : %ld\n" , ftell (in ) ); */
refmax += 1; /* coz 1st value is 0 ! */
i = refmax * 4; /* coz each block is 4 bytes long */
reftab = (uint8 *) malloc (i);
fread (reftab, i, 1, in);
/* go back to pattern data starting address */
fseek (in, PATTERN_DATA, 0); /* SEEK_SET */
/*printf ( "Highest pattern number : %d\n" , pat_max ); */
k = 0;
for (j = 0; j <= pat_max; j++) {
for (i = 0; i < 64; i++) {
/* VOICE #1 */
fread (&c1, 1, 1, in);
k += 1;
fread (&c2, 1, 1, in);
k += 1;
ins = reftab[((c1 << 8) + c2) * 4];
ins = ins >> 2;
note = reftab[((c1 << 8) + c2) * 4 + 1];
Pattern[j][i * 16] = (ins & 0xf0);
Pattern[j][i * 16] |= ptk_table[(note / 2)][0];
Pattern[j][i * 16 + 1] = ptk_table[(note / 2)][1];
Pattern[j][i * 16 + 2] =
reftab[((c1 << 8) + c2) * 4 + 2];
Pattern[j][i * 16 + 2] |= ((ins << 4) & 0xf0);
Pattern[j][i * 16 + 3] =
reftab[((c1 << 8) + c2) * 4 + 3];
if (((Pattern[j][i * 16 + 2] & 0x0f) == 0x0d) ||
((Pattern[j][i * 16 + 2] & 0x0f) == 0x0b)) {
FLAG = ON;
}
/* VOICE #2 */
fread (&c1, 1, 1, in);
k += 1;
fread (&c2, 1, 1, in);
k += 1;
ins = reftab[((c1 << 8) + c2) * 4];
ins = ins >> 2;
note = reftab[((c1 << 8) + c2) * 4 + 1];
Pattern[j][i * 16 + 4] = (ins & 0xf0);
Pattern[j][i * 16 + 4] |= ptk_table[(note / 2)][0];
Pattern[j][i * 16 + 5] = ptk_table[(note / 2)][1];
Pattern[j][i * 16 + 6] =
reftab[((c1 << 8) + c2) * 4 + 2];
Pattern[j][i * 16 + 6] |= ((ins << 4) & 0xf0);
Pattern[j][i * 16 + 7] =
reftab[((c1 << 8) + c2) * 4 + 3];
if (((Pattern[j][i * 16 + 6] & 0x0f) == 0x0d) ||
((Pattern[j][i * 16 + 6] & 0x0f) == 0x0b)) {
FLAG = ON;
}
/* VOICE #3 */
fread (&c1, 1, 1, in);
k += 1;
fread (&c2, 1, 1, in);
k += 1;
ins = reftab[((c1 << 8) + c2) * 4];
ins = ins >> 2;
note = reftab[((c1 << 8) + c2) * 4 + 1];
Pattern[j][i * 16 + 8] = (ins & 0xf0);
if (note != 0)
Pattern[j][i * 16 + 8] |= ptk_table[(note / 2)][0];
Pattern[j][i * 16 + 9] = ptk_table[(note / 2)][1];
Pattern[j][i * 16 + 10] =
reftab[((c1 << 8) + c2) * 4 + 2];
Pattern[j][i * 16 + 10] |= ((ins << 4) & 0xf0);
Pattern[j][i * 16 + 11] =
reftab[((c1 << 8) + c2) * 4 + 3];
if (((Pattern[j][i * 16 + 10] & 0x0f) == 0x0d) ||
((Pattern[j][i * 16 + 10] & 0x0f) == 0x0b)) {
FLAG = ON;
}
/* VOICE #4 */
fread (&c1, 1, 1, in);
k += 1;
fread (&c2, 1, 1, in);
k += 1;
ins = reftab[((c1 << 8) + c2) * 4];
ins = ins >> 2;
note = reftab[((c1 << 8) + c2) * 4 + 1];
Pattern[j][i * 16 + 12] = (ins & 0xf0);
Pattern[j][i * 16 + 12] |= ptk_table[(note / 2)][0];
Pattern[j][i * 16 + 13] = ptk_table[(note / 2)][1];
Pattern[j][i * 16 + 14] =
reftab[((c1 << 8) + c2) * 4 + 2];
Pattern[j][i * 16 + 14] |= ((ins << 4) & 0xf0);
Pattern[j][i * 16 + 15] =
reftab[((c1 << 8) + c2) * 4 + 3];
if (((Pattern[j][i * 16 + 14] & 0x0f) == 0x0d) ||
((Pattern[j][i * 16 + 14] & 0x0f) == 0x0b)) {
FLAG = ON;
}
if (FLAG == ON) {
FLAG = OFF;
break;
}
}
fwrite (Pattern[j], 1024, 1, out);
}
free (reftab);
/* get address of sample data .. and go there */
fseek (in, ADDRESS_SAMPLE_DATA, 0); /* SEEK_SET */
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
fread (&c3, 1, 1, in);
fread (&c4, 1, 1, in);
SDAV = (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
fseek (in, AFTER_REPLAY_CODE + SDAV, 0); /* SEEK_SET */
/* read and save sample data */
/*printf ( "out: where before saving sample data : %ld\n" , ftell ( out ) ); */
/*printf ( "Total sample size : %ld\n" , ssize ); */
sdata = (uint8 *) malloc (ssize);
fread (sdata, ssize, 1, in);
fwrite (sdata, ssize, 1, out);
free (sdata);
Crap ("PM20:Promizer 2.0", BAD, BAD, out);
fflush (in);
fflush (out);
printf ("done\n");
return; /* useless ... but */
}
void Depack_HRT (FILE * in, FILE * out)
{
uint8 Header[2048];
uint8 *tmp;
uint8 c1 = 0x00, c2 = 0x00, c3 = 0x00, c4 = 0x00;
uint8 npat = 0x00;
uint8 ptable[128];
uint8 ptk_table[37][2];
uint8 Max = 0x00;
long ssize = 0;
long i = 0, j = 0;
// FILE *in,*out;
if (Save_Status == BAD)
return;
#include "ptktable.h"
// in = fdopen (fd_in, "rb");
// sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
// out = fdopen (fd_out, "w+b");
memset(Header, 0, 2048);
memset(ptable, 0, 128);
/* read header */
fread (Header, 950, 1, in);
/* empty-ing those adresse values ... */
for (i = 0; i < 31; i++) {
Header[38 + (30 * i)] = 0x00;
Header[38 + (30 * i) + 1] = 0x00;
Header[38 + (30 * i) + 2] = 0x00;
Header[38 + (30 * i) + 3] = 0x00;
}
/* write header */
fwrite (Header, 950, 1, out);
/* get whole sample size */
for (i = 0; i < 31; i++) {
ssize +=
(((Header[42 + (30 * i)] << 8) + Header[43 +
30 * i]) * 2);
}
/*printf ( "Whole sample size : %ld\n" , ssize ); */
/* read number of pattern */
fread (&npat, 1, 1, in);
fwrite (&npat, 1, 1, out);
/*printf ( "Size of pattern list : %d\n" , npat ); */
/* read noisetracker byte and pattern list */
memset(Header, 0, 2048);
fread (Header, 129, 1, in);
fwrite (Header, 129, 1, out);
/* get number of pattern */
Max = 0x00;
for (i = 1; i < 129; i++) {
if (Header[i] > Max)
Max = Header[i];
}
/*printf ( "Number of pattern : %d\n" , Max ); */
/* write ptk's ID */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* pattern data */
fseek (in, 1084, SEEK_SET);
for (i = 0; i <= Max; i++) {
for (j = 0; j < 256; j++) {
fread (&Header[0], 1, 1, in);
fread (&Header[1], 1, 1, in);
fread (&Header[2], 1, 1, in);
fread (&Header[3], 1, 1, in);
Header[0] /= 2;
c1 = Header[0] & 0xf0;
if (Header[1] == 0x00)
c2 = 0x00;
else {
c1 |= ptk_table[(Header[1] / 2)][0];
c2 = ptk_table[(Header[1] / 2)][1];
}
c3 = (Header[0] << 4) & 0xf0;
c3 |= Header[2];
c4 = Header[3];
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c4, 1, 1, out);
}
}
/* sample data */
tmp = (uint8 *) malloc (ssize);
memset(tmp, 0, ssize);
fread (tmp, ssize, 1, in);
fwrite (tmp, ssize, 1, out);
free (tmp);
/* crap */
Crap ("HRT:Hornet Packer", BAD, BAD, out);
fflush (in);
fflush (out);
printf ("done\n");
return; /* useless ... but */
}
/*
* QuadraComposer.c 1999 (c) Asle / ReDoX
*
* Converts QC MODs back to PTK MODs
*
*/
void Depack_QuadraComposer ( void )
{
Uchar c1=0x00,c2=0x00,c3=0x00,c4=0x00,c5=0x00;
Uchar Pat_Pos;
Uchar Pat_Max=0x00;
Uchar Real_Pat_Max=0x00;
Uchar *Whatever;
/*Uchar Row[16];*/
Uchar Pattern[1024];
Uchar NbrSample=0x00;
Uchar RealNbrSample=0x00;
Uchar NbrRow[128];
Uchar poss[37][2]; /* <------ Ptk's pitch table */
long SmpAddresses[32];
long SmpSizes[32];
long PatAddresses[128];
long i=0,j=0,k=0;
long Where = PW_Start_Address;
FILE *out;
if ( Save_Status == BAD )
return;
fillPTKtable(poss);
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
BZERO ( SmpAddresses , 32*4 );
BZERO ( SmpSizes , 32*4 );
BZERO ( PatAddresses , 128*4 );
BZERO ( NbrRow , 128 );
/* bypass ID's and chunk sizes */
Where += 22;
/*fseek ( in , 22 , 0 );*/
/* read and write title */
fwrite ( &in_data[Where], 20, 1, out );
/*for ( i=0 ; i<20 ; i++ )
{
fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
}*/
/* bypass composer and tempo */
Where += 41; /* + title */
/*fseek ( in , 21 , 1 );*/
/* read number of samples */
NbrSample = in_data[Where];
Where += 1;
/*fread ( &NbrSample , 1 , 1 , in );*/
/* write empty 930 sample header */
Whatever = (Uchar *) malloc ( 1024 );
BZERO ( Whatever , 1024 );
Whatever[29] = 0x01;
for ( i=0 ; i<31 ; i++ )
fwrite ( &Whatever[0],30,1,out);
/* read and write sample descriptions */
/*printf ( "sample number:" );*/
for ( i=0 ; i<NbrSample ; i++ )
{
fseek ( out ,20+(in_data[Where]-1)*30 , 0 );
/* read sample number byte */
if ( in_data[Where] > RealNbrSample )
RealNbrSample = in_data[Where];
/* read/write sample name */
fwrite ( &in_data[Where+4],20,1,out );
fwrite ( Whatever,2,1,out ); /* filling */
/* write size */
fwrite ( &in_data[Where+2] , 2 , 1 , out );
/* store size */
SmpSizes[in_data[Where]] = (((in_data[Where+2]*256)+in_data[Where+3])*2);
/* finetune */
fwrite ( &in_data[Where+25], 1, 1, out );
/* write volume */
fwrite ( &in_data[Where+1] , 1 , 1 , out );
/* loops (start & len) */
fwrite ( &in_data[Where+26],2,1,out);
if ( (in_data[Where+28] != 0x00) || (in_data[Where+29] != 0x00) )
fwrite ( &in_data[Where+28],2,1,out);
else
fwrite ( &Whatever[28],2,1,out);
/* read address of this sample in the file */
SmpAddresses[in_data[Where]] =( (in_data[Where+30]*256*256*256) +
(in_data[Where+31]*256*256) +
(in_data[Where+32]*256) +
(in_data[Where+33]) );
Where += 34;
}
/*printf ( "\n" );*/
fseek ( out , 0 , 2 );
/* patterns now */
/* bypass "pad" ?!? */
/*fread ( &c1 , 1 , 1 , in );*/
if ( in_data[Where] == 0x00 )
/*fseek ( in , -1 , 1 );*/
Where += 1;
/* read number of pattern */
Pat_Max = in_data[Where++];
/*fread ( &Pat_Max , 1 , 1 , in );*/
/* printf ( "\nPat_Max : %d (at %x)\n" , Pat_Max , ftell ( in ) );*/
/* read patterns info */
/*printf ( "pattern numbers:" );*/
for ( i=0 ; i<Pat_Max ; i++ )
{
/* read pattern number */
c5 = in_data[Where++];
/*fread ( &c5 , 1 , 1 , in );*/
/*printf ("%d," , c5);*/
/* read number of rows for each pattern */
NbrRow[c5] = in_data[Where++];
/*fread ( &NbrRow[c5] , 1 , 1 , in );*/
/* bypass pattern name */
Where += 20;
/*fseek ( in , 20 , 1 );*/
/* read pattern address */
/*fread ( &c1 , 1 , 1 , in );
fread ( &c2 , 1 , 1 , in );
fread ( &c3 , 1 , 1 , in );
fread ( &c4 , 1 , 1 , in );*/
PatAddresses[c5] = ( (in_data[Where]*256*256*256) +
(in_data[Where+1]*256*256) +
(in_data[Where+2]*256) +
(in_data[Where+3]) );
Where += 4;
}
/*printf ("\n");*/
/* pattern list */
/* bypass "pad" ?!? */
/*fread ( &c1 , 1 , 1 , in );*/
if ( in_data[Where] == 0x00 )
/*fseek ( in , -1 , 1 );*/
Where += 1;
/* read/write number of position */
Pat_Pos = in_data[Where++];
/*fread ( &Pat_Pos , 1 , 1 , in );*/
fwrite ( &Pat_Pos , 1 , 1 , out );
/* write noisetracker byte */
c1 = 0x7f;
fwrite ( &c1 , 1 , 1 , out );
/* read/write pattern list */
for ( i=0 ; i<Pat_Pos ; i++ )
{
/*fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );*/
fwrite ( &in_data[Where],1,1,out);
if ( in_data[Where] > Real_Pat_Max )
Real_Pat_Max = in_data[Where];
Where += 1;
}
/*printf ( "Real_Pat_Max : %d\n" , Real_Pat_Max );*/
/* fill up to 128 */
BZERO (Whatever,930);
fwrite ( Whatever , 128 , 1 , out );
/* write ptk's ID */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
fwrite ( &c3 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
/* pattern data */
/*printf ( "patterns('-'=empty):" );*/
for ( i=0 ; i<=Real_Pat_Max ; i++ )
{
BZERO ( Pattern , 1024 );
if ( PatAddresses[i] == 0l )
{
/*printf ( "-(%d)" , NbrRow[i] );*/
fwrite ( Pattern , 1024 , 1 , out );
/* printf ( "-" );*/
continue;
}
/*printf ( "#" );*/
Where = PW_Start_Address + PatAddresses[i];
/*fseek ( in , PatAddresses[i] , 0 );*/
for ( j=0 ; j<=NbrRow[i] ; j++ )
{
/*BZERO ( Row , 16 );*/
/*fread ( Row , 16 , 1 , in );*/
for ( k=0 ; k<4 ; k++ )
{
/* Fx */
/*Pattern[j*16+k*4+2] = Row[k*4+2];*/
Pattern[j*16+k*4+2] = in_data[Where+k*4+2];
/* Fx args */
switch ( Pattern[j*16+k*4+2] )
{
case 0x09:
/*printf ( "#" );*/
/*Pattern[j*16+k*4+3] = (Row[k*4+3]*2);*/
Pattern[j*16+k*4+3] = (in_data[Where+k*4+3]*2);
break;
case 0x0b:
/*printf ( "!" );*/
/*c4 = Row[k*4+3]%10;
c3 = Row[k*4+3]/10;*/
c4 = in_data[Where+k*4+3]%10;
c3 = in_data[Where+k*4+3]/10;
Pattern[j*16+k*4+3] = 16;
Pattern[j*16+k*4+3] *= c3;
Pattern[j*16+k*4+3] += c4;
break;
case 0x0E:
/*if ( (Row[k*4+3]&0xf0) == 0xf0 )*/
if ( (in_data[Where+k*4+3]&0xf0) == 0xf0 )
/*Pattern[j*16+k*4+3] = (Row[k*4+3]-0x10);*/
Pattern[j*16+k*4+3] = (in_data[Where+k*4+3]-0x10);
break;
default:
/*Pattern[j*16+k*4+3] = Row[k*4+3];*/
Pattern[j*16+k*4+3] = in_data[Where+k*4+3];
}
/* smp nbr (4 lower bits) */
/*Pattern[j*16+k*4+2] |= ((Row[k*4]<<4)&0xf0);*/
Pattern[j*16+k*4+2] |= ((in_data[Where+k*4]<<4)&0xf0);
/* notes */
/*c1 = Row[k*4+1];*/
c1 = in_data[Where+k*4+1];
if ( c1 != 0xff )
{
Pattern[j*16+k*4] = poss[c1][0];
Pattern[j*16+k*4+1] = poss[c1][1];
}
/* smp nbr (4 higher bits) */
/*Pattern[j*16+k*4] |= (Row[k*4]&0xf0);*/
Pattern[j*16+k*4] |= (in_data[Where+k*4]&0xf0);
}
Where += 16;
}
fwrite ( Pattern , 1024 , 1 , out );
}
/* sample data */
/*printf ( "\nsamples('-'=empty):" );*/
for ( i=1 ; i<=RealNbrSample ; i++ )
{
if ( SmpSizes[i] == 0 )
{
/*printf ( "-(%ld)" , SmpSizes[i] );*/
continue;
}
/*printf ( "#" );*/
Where = PW_Start_Address + SmpAddresses[i];
fwrite ( &in_data[Where] , SmpSizes[i] , 1 , out );
}
/*printf ( "\n" );*/
/* printf ( "\nwhere: %ld\n" , ftell ( in ) );*/
/* crap */
Crap ( " Quadra Composer " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
/*
* nfh.c 2003 (c) Asle / ReDoX
*
* converts ziks from Noise From Heaven chiptune diskmag by Iris'01
*
*/
void Depack_NFH ( void )
{
Uchar *Whatever;
Uchar poss[37][2];
Uchar Max=0x00;
long WholeSampleSize=0;
long i=0,j=0;
long Where=PW_Start_Address;
FILE *out;
fillPTKtable(poss);
if ( Save_Status == BAD )
return;
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* read and write whole header */
fwrite ( &in_data[Where] , 1080 , 1 , out );
/* get whole sample size */
for ( i=0 ; i<31 ; i++ )
{
WholeSampleSize += (((in_data[Where+42+i*30]*256)+in_data[Where+43+i*30])*2);
}
/*printf ( "Whole sanple size : %ld\n" , WholeSampleSize );*/
Where += 952 /* after size of pattern list .. before pattern list itself */;
/* write ID */
Whatever = (Uchar *) malloc (4);
Whatever[0] = 'M';
Whatever[1] = '.';
Whatever[2] = 'K';
Whatever[3] = '.';
fwrite ( Whatever , 4 , 1 , out );
/* get number of pattern */
Max = 0x00;
for ( i=0 ; i<128 ; i++ )
{
if ( in_data[Where+i] > Max )
Max = in_data[Where+i];
}
/*printf ( "Number of pattern : %d\n" , Max );*/
/* pattern data */
Where = PW_Start_Address + 1084;
for ( i=0 ; i<=Max ; i++ )
{
for ( j=0 ; j<256 ; j++ )
{
Whatever[0] = in_data[Where] & 0xf0;
Whatever[2] = (in_data[Where] & 0x0f)<<4;
Whatever[2] |= (in_data[Where+2]/2);
Whatever[3] = in_data[Where+3];
Whatever[0] |= poss[(in_data[Where+1]/2)][0];
Whatever[1] = poss[(in_data[Where+1]/2)][1];
fwrite ( Whatever , 4 , 1 , out );
Where += 4;
}
}
free ( Whatever );
/* sample data */
fwrite ( &in_data[Where] , WholeSampleSize , 1 , out );
/* crap */
Crap ( "Noise From Heaven " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_PP10 (FILE * in, FILE * out)
{
uint8 c1 = 0x00, c2 = 0x00, c3 = 0x00, c4 = 0x00;
uint8 Tracks_Numbers[4][128];
uint8 pat_pos;
uint8 *tmp;
uint8 Pattern[1024];
short Max;
long i = 0, j = 0, k = 0;
long ssize = 0;
// FILE *in,*out;
if (Save_Status == BAD)
return;
memset(Tracks_Numbers, 0, 128 * 4);
// in = fdopen (fd_in, "rb");
// sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
// out = fdopen (fd_out, "w+b");
/* write title */
for (i = 0; i < 20; i++)
fwrite (&c1, 1, 1, out);
/* read and write sample descriptions */
for (i = 0; i < 31; i++) {
c1 = 0x00;
for (j = 0; j < 22; j++) /*sample name */
fwrite (&c1, 1, 1, out);
xmp_fread (&c1, 1, 1, in); /* size */
xmp_fread (&c2, 1, 1, in);
ssize += (((c1 << 8) + c2) * 2);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
xmp_fread (&c1, 1, 1, in); /* finetune */
fwrite (&c1, 1, 1, out);
xmp_fread (&c1, 1, 1, in); /* volume */
fwrite (&c1, 1, 1, out);
xmp_fread (&c1, 1, 1, in); /* loop start */
xmp_fread (&c2, 1, 1, in);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
xmp_fread (&c1, 1, 1, in); /* loop size */
xmp_fread (&c2, 1, 1, in);
if ((c1 == 0x00) && (c2 == 0x00))
c2 = 0x01;
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
}
/*printf ( "Whole sample size : %ld\n" , ssize ); */
/* read and write pattern table lenght */
xmp_fread (&pat_pos, 1, 1, in);
fwrite (&pat_pos, 1, 1, out);
/*printf ( "Size of pattern list : %d\n" , pat_pos ); */
/* read and write NoiseTracker byte */
xmp_fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
/* read track list and get highest track number */
Max = 0;
for (j = 0; j < 4; j++) {
for (i = 0; i < 128; i++) {
xmp_fread (&Tracks_Numbers[j][i], 1, 1, in);
if (Tracks_Numbers[j][i] > Max)
Max = Tracks_Numbers[j][i];
}
}
/*printf ( "highest track number : %d\n" , Max+1 ); */
/* write pattern table "as is" ... */
for (c1 = 0x00; c1 < pat_pos; c1++)
fwrite (&c1, 1, 1, out);
c2 = 0x00;
for (; c1 < 128; c1++)
fwrite (&c2, 1, 1, out);
/* write ptk's ID */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* track/pattern data */
for (i = 0; i < pat_pos; i++) {
/*fprintf ( info , "\n\n\nPattern %ld :\n" , i );*/
memset(Pattern, 0, 1024);
for (j = 0; j < 4; j++) {
fseek (in, 762 + (Tracks_Numbers[j][i] << 8), 0); /* SEEK_SET */
/*fprintf ( info , "Voice %ld :\n" , j );*/
for (k = 0; k < 64; k++) {
xmp_fread (&c1, 1, 1, in);
xmp_fread (&c2, 1, 1, in);
xmp_fread (&c3, 1, 1, in);
xmp_fread (&c4, 1, 1, in);
/*fprintf ( info , "%2x , %2x , %2x (%ld)\n" , c2 , c3 , c4 ,ftell (in));*/
Pattern[k * 16 + j * 4] = c1;
Pattern[k * 16 + j * 4 + 1] = c2;
Pattern[k * 16 + j * 4 + 2] = c3;
Pattern[k * 16 + j * 4 + 3] = c4;
}
}
fwrite (Pattern, 1024, 1, out);
/*printf ( "+" ); */
}
/*printf ( "\n" ); */
/* now, lets put file pointer at the beginning of the sample datas */
fseek (in, 762 + ((Max + 1) << 8), 0); /* SEEK_SET */
/* sample data */
tmp = (uint8 *) malloc (ssize);
xmp_fread (tmp, ssize, 1, in);
fwrite (tmp, ssize, 1, out);
free (tmp);
/* crap */
Crap ("PP10:ProPacker v1.0", BAD, BAD, out);
fflush (in);
fflush (out);
printf ("done\n");
return; /* useless ... but */
}
/*
* PhaPacker.c 1996-2003 (c) Asle / ReDoX
*
* Converts PHA packed MODs back to PTK MODs
* nth revision :(.
*
* update (15 mar 2003)
* - numerous bugs corrected ... seems to work now ... hum ?
* update (8 dec 2003)
* - removed fopen()
*/
void Depack_PHA ( void )
{
Uchar c1=0x00,c2=0x00,c3=0x00;
Uchar poss[37][2];
Uchar *Whole_Pattern_Data;
Uchar *Pattern;
Uchar *Whatever;
Uchar Old_Note_Value[4][4];
Uchar Note,Smp,Fx,FxVal;
Uchar PatMax=0x00;
long MyPatList[128];
long Pats_Address[128];
long i=0,j=0,k=0;
long Start_Pat_Address=9999999l;
long Whole_Pattern_Data_Size;
long Whole_Sample_Size=0;
long Sample_Data_Address;
long Where = PW_Start_Address;
short Old_cpt[4];
FILE *out;/*,*info;*/
if ( Save_Status == BAD )
return;
fillPTKtable(poss);
BZERO ( Pats_Address , 128*4 );
BZERO ( Old_Note_Value , 4*4 );
BZERO ( Old_cpt , 4*2 );
BZERO ( MyPatList, 128*sizeof(long));
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* info = fopen ( "info", "w+b");*/
for ( i=0 ; i<20 ; i++ ) /* title */
fwrite ( &c1 , 1 , 1 , out );
Whatever = (Uchar *) malloc (64);
for ( i=0 ; i<31 ; i++ )
{
BZERO ( Whatever, 64 );
/*sample name*/
fwrite ( &Whatever[32] , 22 , 1 , out );
/* size */
fwrite ( &in_data[Where] , 2 , 1 , out );
Whole_Sample_Size += (((in_data[Where]*256)+in_data[Where+1])*2);
/* finetune */
c1 = ( Uchar ) (((in_data[Where+12]*256)+in_data[Where+13])/0x48);
fwrite ( &c1 , 1 , 1 , out );
/* volume */
fwrite ( &in_data[Where+3] , 1 , 1 , out );
/* loop start */
fwrite ( &in_data[Where+4] , 2 , 1 , out );
/* loop size */
fwrite ( &in_data[Where+6] , 2 , 1 , out );
Where += 14;
}
/*printf ( "Whole sample size : %ld\n" , Whole_Sample_Size );*/
/* bypass those unknown 14 bytes */
Where += 14;
for ( i=0 ; i<128 ; i++ )
{
Pats_Address[i] = (in_data[Where]*256*256*256)+(in_data[Where+1]*256*256)+(in_data[Where+2]*256)+in_data[Where+3];
Where += 4;
/*fprintf ( info, "%3ld: %ld\n" , i,Pats_Address[i] );*/
if ( Pats_Address[i] < Start_Pat_Address )Start_Pat_Address = Pats_Address[i];
}
Sample_Data_Address = Where;
/* printf ( "Sample data address : %ld\n", Sample_Data_Address);*/
/*printf ( "address of the first pattern : %ld\n" , Start_Pat_Address );*/
/* pattern datas */
/* read ALL pattern data */
Whole_Pattern_Data_Size = OutputSize - Start_Pat_Address;
Whole_Pattern_Data = (Uchar *) malloc ( Whole_Pattern_Data_Size );
Where = Start_Pat_Address + PW_Start_Address;
for (i=0;i<Whole_Pattern_Data_Size;i++)Whole_Pattern_Data[i] = in_data[Where+i];
/* printf ( "Whole pattern data size : %ld\n" , Whole_Pattern_Data_Size );*/
Pattern = (Uchar *) malloc ( 65536 );
BZERO ( Pattern , 65536 );
j=0;k=0;c1=0x00;
for ( i=0 ; i<Whole_Pattern_Data_Size ; i++ )
{
if ((k%256)==0)
{
MyPatList[c1] = Start_Pat_Address+i;
/* fprintf (info, "-> new patter [addy:%ld] [nbr:%d]\n", MyPatList[c1], c1);*/
c1 += 0x01;
}
if ( Whole_Pattern_Data[i] == 0xff )
{
i += 1;
/* Old_cpt[(k+3)%4] = 0xff - Whole_Pattern_Data[i];*/
Old_cpt[(k-1)%4] = 0xff - Whole_Pattern_Data[i];
/* fprintf (info, "-> count set to [%d] for voice [%ld]\n",Old_cpt[(k-1)%4],(k-1)%4 );*/
/*k += 1;*/
continue;
}
if ( Old_cpt[k%4] != 0 )
{
Smp = Old_Note_Value[k%4][0];
Note = Old_Note_Value[k%4][1];
Fx = Old_Note_Value[k%4][2];
FxVal = Old_Note_Value[k%4][3];
/* fprintf ( info, "[%5ld]-[%ld] %2x %2x %2x %2x [%ld] [%6ld] (count : %d)\n",i,k%4,Smp,Note,Fx,FxVal,j,MyPatList[c1-1],Old_cpt[k%4] );*/
Old_cpt[k%4] -= 1;
Pattern[j] = Smp&0xf0;
Pattern[j] |= poss[(Note/2)][0];
Pattern[j+1] = poss[(Note/2)][1];
Pattern[j+2] = (Smp<<4)&0xf0;
Pattern[j+2] |= Fx;
Pattern[j+3] = FxVal;
k+=1;
j+=4;
i-=1;
continue;
}
Smp = Whole_Pattern_Data[i];
Note = Whole_Pattern_Data[i+1];
Fx = Whole_Pattern_Data[i+2];
FxVal = Whole_Pattern_Data[i+3];
Old_Note_Value[k%4][0] = Smp;
Old_Note_Value[k%4][1] = Note;
Old_Note_Value[k%4][2] = Fx;
Old_Note_Value[k%4][3] = FxVal;
/* fprintf ( info, "[%5ld]-[%ld] %2x %2x %2x %2x [%ld] [%6ld]\n",i,k%4,Smp,Note,Fx,FxVal,j, MyPatList[c1-1]);*/
/* fflush (info);*/
i += 3;
Pattern[j] = Smp&0xf0;
Pattern[j] |= poss[(Note/2)][0];
Pattern[j+1] = poss[(Note/2)][1];
Pattern[j+2] = (Smp<<4)&0xf0;
Pattern[j+2] |= Fx;
Pattern[j+3] = FxVal;
k+=1;
j+=4;
}
PatMax = c1;
/*
fprintf ( info , "pats address pats address tmp\n" );
for ( i=0 ; i<128 ; i++ )
{
fprintf ( info , "%3ld: %6ld %ld [%ld]\n" , i , Pats_Address[i] , Pats_Address_tmp[i],MyPatList[i] );
}
fflush ( info );*/
/* try to get the number of pattern in pattern list */
for ( c1=128 ; c1>0x00 ; c1-=0x01 )
if ( Pats_Address[c1] != Pats_Address[127] )
break;
/* write this value */
c1 += 1;
fwrite ( &c1 , 1 , 1 , out );
/* ntk restart byte */
c2 = 0x7f;
fwrite ( &c2 , 1 , 1 , out );
/* write pattern list */
for ( i=0 ; i<128 ; i++ )
{
for (c1=0x00; Pats_Address[i]!=MyPatList[c1];c1+=0x01);
fwrite ( &c1 , 1 , 1 , out );
}
/* ID string */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
fwrite ( &c3 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
fwrite ( Pattern , PatMax*1024 , 1 , out );
free ( Whole_Pattern_Data );
free ( Pattern );
/* Sample data */
fwrite ( &in_data[Sample_Data_Address] , Whole_Sample_Size , 1 , out );
Crap ( " PhaPacker " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
/*
* FC-M_Packer.c 1997 (c) Asle / ReDoX
*
* Converts back to ptk FC-M packed MODs
*
* Last update: 28/11/99
* - removed open() (and other fread()s and the like)
* - general Speed & Size Optmizings
* 20051002 : testing fopen()
*/
void Depack_FC_M ( void )
{
Uchar *Whatever;
long i=0;
long WholeSampleSize=0;
long Where = PW_Start_Address;
FILE *out;
if ( Save_Status == BAD )
return;
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* bypass "FC-M" ID */
/* bypass what looks like the version number .. */
/* bypass "NAME" chunk */
/*Where += 10;*/
/* read and write title */
fwrite ( &in_data[Where+10] , 20 , 1 , out );
/* bypass "INST" chunk */
Where += 34;
/* read and write sample descriptions */
Whatever = (Uchar *)malloc(256);
BZERO ( Whatever , 256 );
for ( i=0 ; i<31 ; i++ )
{
/*sample name*/
fwrite ( Whatever , 22 , 1 , out );
WholeSampleSize += (((in_data[Where]*256)+in_data[Where+1])*2);
fwrite ( &in_data[Where] , 6 , 1 , out );
Whatever[32] = in_data[Where+7];
if ( (in_data[Where+6] == 0x00) && (in_data[Where+7] == 0x00) )
Whatever[32] = 0x01;
fwrite ( &in_data[Where+6] , 1 , 1 , out );
fwrite ( &Whatever[32] , 1 , 1 , out );
Where += 8;
}
/*printf ( "Whole sample size : %ld\n" , WholeSampleSize );*/
/* bypass "LONG" chunk */
Where += 4;
/* read and write pattern table lenght */
Whatever[128] = in_data[Where++];
fwrite ( &Whatever[128] , 1 , 1 , out );
/*printf ( "Size of pattern list : %d\n" , Whatever[128] );*/
/* read and write NoiseTracker byte */
fwrite ( &in_data[Where] , 1 , 1 , out );
/* bypass "PATT" chunk */
Where += 5;
/* read and write pattern list and get highest patt number */
for ( i=0 ; i<Whatever[128] ; i++ )
{
Whatever[i] = in_data[Where];
if ( in_data[Where] > Whatever[129] )
Whatever[129] = in_data[Where];
Where += 1;
}
fwrite ( Whatever , 128 , 1 , out );
/*printf ( "Number of pattern : %d\n" , Whatever[129] + 1 );*/
/* write ptk's ID */
Whatever[0] = 'M';
Whatever[1] = '.';
Whatever[2] = 'K';
Whatever[3] = '.';
fwrite ( Whatever , 4 , 1 , out );
/* bypass "SONG" chunk */
Where += 4;
/* pattern data */
for ( i=0 ; i<=Whatever[129] ; i++ )
{
fwrite ( &in_data[Where] , 1024 , 1 , out );
Where += 1024;
/*printf ( "+" );*/
}
free ( Whatever );
/*printf ( "\n" );*/
/* bypass "SAMP" chunk */
Where += 4;
/* sample data */
fwrite ( &in_data[Where] , WholeSampleSize , 1 , out );
/* crap */
Crap ( " FC-M packer " , BAD , BAD , out );
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
void Depack_SoundFX13 ( void )
{
Uchar *Whatever;
Uchar c0=0x00,c1=0x00,c2=0x00,c3=0x00;
Uchar Max=0x00;
Uchar PatPos;
long WholeSampleSize=0;
long i=0,j=0;
FILE *in,*out;
if ( Save_Status == BAD )
return;
in = fopen ( (char *)OutName_final , "r+b" ); /* +b is safe bcoz OutName's just been saved */
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* title */
Whatever = (Uchar *) malloc ( 20 );
BZERO ( Whatever , 20 );
fwrite ( Whatever , 20 , 1 , out );
free ( Whatever );
/* read and write whole header */
for ( i=0 ; i<15 ; i++ )
{
fseek ( in , 0x50 + i*30 , 0 );
/* write name */
for ( j=0 ; j<22 ; j++ )
{
fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
}
/* size */
fseek ( in , i*4 + 1 , 0 );
fread ( &c0 , 1 , 1 , in );
fread ( &c1 , 1 , 1 , in );
fread ( &c2 , 1 , 1 , in );
c2 /= 2;
c3 = c1/2;
if ( (c3*2) != c1 )
c2 += 0x80;
if (c0 != 0x00)
c3 += 0x80;
fseek ( in , 0x50 + i*30 + 24 , 0 );
fwrite ( &c3 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
WholeSampleSize += (((c3*256)+c2)*2);
/* finetune */
fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
/* volume */
fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
/* loop start */
fread ( &c1 , 1 , 1 , in );
fread ( &c2 , 1 , 1 , in );
c2 /= 2;
c3 = c1/2;
if ( (c3*2) != c1 )
c2 += 0x80;
fwrite ( &c3 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
/* loop size */
fread ( &c1 , 1 , 1 , in );
fread ( &c2 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
}
free ( Whatever );
Whatever = (Uchar *) malloc ( 30 );
BZERO ( Whatever , 30 );
Whatever[29] = 0x01;
for ( i=0 ; i<16 ; i++ )
fwrite ( Whatever , 30 , 1 , out );
free ( Whatever );
/* pattern list size */
fread ( &PatPos , 1 , 1 , in );
fwrite ( &PatPos , 1 , 1 , out );
/* ntk byte */
fseek ( in , 1 , 1 );
c1 = 0x7f;
fwrite ( &c1 , 1 , 1 , out );
/* read and write pattern list */
Max = 0x00;
for ( i=0 ; i<PatPos ; i++ )
{
fread ( &c1 , 1 , 1 , in );
fwrite ( &c1 , 1 , 1 , out );
if ( c1 > Max )
Max = c1;
}
c1 = 0x00;
while ( i != 128 )
{
fwrite ( &c1 , 1 , 1 , out );
i+=1;
}
/* write ID */
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite ( &c1 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
fwrite ( &c3 , 1 , 1 , out );
fwrite ( &c2 , 1 , 1 , out );
/* pattern data */
fseek ( in , 0x294 , 0 );
Whatever = (Uchar *) malloc ( 1024 );
for ( i=0 ; i<=Max ; i++ )
{
BZERO ( Whatever , 1024 );
fread ( Whatever , 1024 , 1 , in );
for ( j=0 ; j<256 ; j++ )
{
if ( Whatever[(j*4)] == 0xff )
{
if ( Whatever[(j*4)+1] != 0xfe )
printf ( "Volume unknown : (at:%ld) (fx:%x,%x,%x,%x)\n" , ftell (in)
, Whatever[(j*4)]
, Whatever[(j*4)+1]
, Whatever[(j*4)+2]
, Whatever[(j*4)+3] );
Whatever[(j*4)] = 0x00;
Whatever[(j*4)+1] = 0x00;
Whatever[(j*4)+2] = 0x0C;
Whatever[(j*4)+3] = 0x00;
continue;
}
switch ( Whatever[(j*4)+2]&0x0f )
{
case 1: /* arpeggio */
Whatever[(j*4)+2] &= 0xF0;
break;
case 7: /* slide up */
case 8: /* slide down */
Whatever[(j*4)+2] -= 0x06;
break;
case 3: /* empty ... same as followings ... but far too much to "printf" it */
case 6: /* and Noiseconverter puts 00 instead ... */
Whatever[(j*4)+2] &= 0xF0;
Whatever[(j*4)+3] = 0x00;
break;
case 2:
case 4:
case 5:
case 9:
case 0x0a:
case 0x0b:
case 0x0c:
case 0x0d:
case 0x0e:
case 0x0f:
printf ( "unsupported effect : (at:%ld) (fx:%d)\n" , ftell (in) , Whatever[(j*4)+2]&0x0f );
Whatever[(j*4)+2] &= 0xF0;
Whatever[(j*4)+3] = 0x00;
break;
default:
break;
}
}
fwrite ( Whatever , 1024 , 1 , out );
fflush ( stdout );
}
free ( Whatever );
fflush ( stdout );
/* sample data */
Whatever = (Uchar *) malloc ( WholeSampleSize );
BZERO ( Whatever , WholeSampleSize );
fread ( Whatever , WholeSampleSize , 1 , in );
fwrite ( Whatever , WholeSampleSize , 1 , out );
free ( Whatever );
fflush ( stdout );
/* crap */
Crap ( " Sound FX " , BAD , BAD , out );
fflush ( in );
fflush ( out );
fclose ( in );
fclose ( out );
printf ( "done\n"
" WARNING: This is only an under development converter !\n"
" output could sound strange...\n" );
return; /* useless ... but */
}
void Depack_PP21 (FILE * in, FILE * out)
{
uint8 c1 = 0x00, c2 = 0x00, c3 = 0x00, c4 = 0x00;
uint8 ptable[128];
short Max = 0;
uint8 Tracks_Numbers[4][128];
short Tracks_PrePointers[512][64];
uint8 NOP = 0x00; /* number of pattern */
uint8 *reftab;
uint8 Pattern[1024];
long i = 0, j = 0;
long ssize = 0;
long RTS = 0; /* Reference Table Size */
// FILE *in,*out;
if (Save_Status == BAD)
return;
memset(ptable, 0, 128);
memset(Tracks_Numbers, 0, 4 * 128);
memset(Tracks_PrePointers, 0, 512 * 128);
// in = fdopen (fd_in, "rb");
// sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
// out = fdopen (fd_out, "w+b");
for (i = 0; i < 20; i++) /* title */
fwrite (&c1, 1, 1, out);
for (i = 0; i < 31; i++) {
c1 = 0x00;
for (j = 0; j < 22; j++) /*sample name */
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* size */
fread (&c2, 1, 1, in);
ssize += (((c1 << 8) + c2) * 2);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fread (&c1, 1, 1, in); /* finetune */
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* volume */
fwrite (&c1, 1, 1, out);
fread (&c1, 1, 1, in); /* loop start */
fread (&c2, 1, 1, in);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fread (&c1, 1, 1, in); /* loop size */
fread (&c2, 1, 1, in);
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
}
/* pattern table lenght */
fread (&NOP, 1, 1, in);
fwrite (&NOP, 1, 1, out);
/*printf ( "Number of patterns : %d\n" , NOP ); */
/* NoiseTracker restart byte */
fread (&c1, 1, 1, in);
fwrite (&c1, 1, 1, out);
Max = 0;
for (j = 0; j < 4; j++) {
for (i = 0; i < 128; i++) {
fread (&c1, 1, 1, in);
Tracks_Numbers[j][i] = c1;
if (Tracks_Numbers[j][i] > Max)
Max = Tracks_Numbers[j][i];
}
}
/*printf ( "Number of tracks : %d\n" , Max+1 ); */
/* write pattern table without any optimizing ! */
for (c1 = 0x00; c1 < NOP; c1++)
fwrite (&c1, 1, 1, out);
c4 = 0x00;
for (; c1 < 128; c1++)
fwrite (&c4, 1, 1, out);
c1 = 'M';
c2 = '.';
c3 = 'K';
fwrite (&c1, 1, 1, out);
fwrite (&c2, 1, 1, out);
fwrite (&c3, 1, 1, out);
fwrite (&c2, 1, 1, out);
/* PATTERN DATA code starts here */
/*printf ( "Highest track number : %d\n" , Max ); */
for (j = 0; j <= Max; j++) {
for (i = 0; i < 64; i++) {
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
Tracks_PrePointers[j][i] = (c1 << 8) + c2;
}
}
/* read "reference table" size */
fread (&c1, 1, 1, in);
fread (&c2, 1, 1, in);
fread (&c3, 1, 1, in);
fread (&c4, 1, 1, in);
RTS = (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
/* read "reference Table" */
/*printf ( "Reference table location : %ld\n" , ftell (in) ); */
reftab = (uint8 *) malloc (RTS);
fread (reftab, RTS, 1, in);
/* NOW, the real shit takes place :) */
for (i = 0; i < NOP; i++) {
memset(Pattern, 0, 1024);
for (j = 0; j < 64; j++) {
Pattern[j * 16] =
reftab[Tracks_PrePointers
[Tracks_Numbers[0][i]][j] * 4];
Pattern[j * 16 + 1] =
reftab[Tracks_PrePointers
[Tracks_Numbers[0][i]][j] * 4 + 1];
Pattern[j * 16 + 2] =
reftab[Tracks_PrePointers
[Tracks_Numbers[0][i]][j] * 4 + 2];
Pattern[j * 16 + 3] =
reftab[Tracks_PrePointers
[Tracks_Numbers[0][i]][j] * 4 + 3];
Pattern[j * 16 + 4] =
reftab[Tracks_PrePointers
[Tracks_Numbers[1][i]][j] * 4];
Pattern[j * 16 + 5] =
reftab[Tracks_PrePointers
[Tracks_Numbers[1][i]][j] * 4 + 1];
Pattern[j * 16 + 6] =
reftab[Tracks_PrePointers
[Tracks_Numbers[1][i]][j] * 4 + 2];
Pattern[j * 16 + 7] =
reftab[Tracks_PrePointers
[Tracks_Numbers[1][i]][j] * 4 + 3];
Pattern[j * 16 + 8] =
reftab[Tracks_PrePointers
[Tracks_Numbers[2][i]][j] * 4];
Pattern[j * 16 + 9] =
reftab[Tracks_PrePointers
[Tracks_Numbers[2][i]][j] * 4 + 1];
Pattern[j * 16 + 10] =
reftab[Tracks_PrePointers
[Tracks_Numbers[2][i]][j] * 4 + 2];
Pattern[j * 16 + 11] =
reftab[Tracks_PrePointers
[Tracks_Numbers[2][i]][j] * 4 + 3];
Pattern[j * 16 + 12] =
reftab[Tracks_PrePointers
[Tracks_Numbers[3][i]][j] * 4];
Pattern[j * 16 + 13] =
reftab[Tracks_PrePointers
[Tracks_Numbers[3][i]][j] * 4 + 1];
Pattern[j * 16 + 14] =
reftab[Tracks_PrePointers
[Tracks_Numbers[3][i]][j] * 4 + 2];
Pattern[j * 16 + 15] =
reftab[Tracks_PrePointers
[Tracks_Numbers[3][i]][j] * 4 + 3];
}
fwrite (Pattern, 1024, 1, out);
}
free (reftab);
/* Now, it's sample data ... though, VERY quickly handled :) */
/* thx GCC ! (GNU C COMPILER). */
/*printf ( "Total sample size : %ld\n" , ssize ); */
reftab = (uint8 *) malloc (ssize);
fread (reftab, ssize, 1, in);
fwrite (reftab, ssize, 1, out);
free (reftab);
Crap ("PP21:ProPacker v2.1", BAD, BAD, out);
fflush (in);
fflush (out);
printf ("done\n");
return; /* useless ... but */
}
/*
* Skizzo.c 2007 (c) Asle / ReDoX
*
* 20070525 : doesn't convert pattern data
*/
void Depack_Skizzo ( void )
{
Uchar *Whatever;
long i=0,k=0;
Ushort Pattern_Addresses_Table[128];
short BODYaddy, SAMPaddy, nbr_sample, siz_patlist, nbr_patstored;
long Total_Sample_Size=0;
long Where = PW_Start_Address;
Uchar poss[37][2];
FILE *out,*DEBUG;
/* filling up the possible PTK notes */
fillPTKtable(poss);
/* DEBUG = fopen("DEBUG.txt","w+b");*/
if ( Save_Status == BAD )
return;
sprintf ( Depacked_OutName , "%ld.mod" , Cpt_Filename-1 );
out = PW_fopen ( Depacked_OutName , "w+b" );
/* title */
Whatever = (Uchar *) malloc (2048);
BZERO ( Whatever , 2048 );
/* write title */
fwrite ( &in_data[Where], 20, 1, out );
Where += 20;
/* read size of patternlist */
siz_patlist = in_data[Where]; /* &0x7F necessary ! */
Where += 2; /* with bypassing an unknown '00' */
/* read number of sample */
nbr_sample = in_data[Where];
Where += 1;
/* read nbr of pattern saved */
nbr_patstored = in_data[Where];
Where += 5; /* bypassing '-GD-' too */
/* sample header */
BZERO ( Whatever, 2048 );
for ( i=0 ; i<nbr_sample ; i++ )
{
/* size */
Whatever[22+(i*30)] = in_data[Where];
Whatever[23+(i*30)] = in_data[Where+1];
Total_Sample_Size += ((in_data[Where]*256)+in_data[Where+1])*2;
/* finetune */
Whatever[24+(i*30)] = in_data[Where+2];
/* volume */
Whatever[25+(i*30)] = in_data[Where+3];
/* loop start */
Whatever[26+(i*30)] = in_data[Where+4];
Whatever[27+(i*30)] = in_data[Where+5];
/* loop size */
Whatever[28+(i*30)] = in_data[Where+6];
Whatever[29+(i*30)] = in_data[Where+7];
Where += 8;
}
/* finally, write the PTK header */
fwrite ( Whatever , 930 , 1 , out );
/* pattern list now */
/* 'Where' is on it */
BZERO ( Whatever, 2048 );
for ( i=2; i<(siz_patlist&0x7f)+2; i++ )
{
Whatever[i] = in_data[Where];
Where += 1;
}
Whatever[i+1] = (nbr_patstored - 1);
Whatever[0] = (Uchar)(siz_patlist&0x7f);
Whatever[1] = 0x7F;
fwrite ( Whatever , 130 , 1 , out );
/* PTK's tag now*/
Whatever[0] = 'M';
Whatever[1] = '.';
Whatever[2] = 'K';
Whatever[3] = '.';
fwrite ( Whatever , 4 , 1 , out );
/*
fprintf(DEBUG,"nbr_sample : %d\n",nbr_sample);
fprintf(DEBUG,"siz_patlist : %d\n",siz_patlist&0x7f);
fprintf(DEBUG,"nbr_patstored : %d\n\n",nbr_patstored);
*/
/* pattern data now ... */
for ( i=0 ; i<nbr_patstored ; i++ )
/* for ( i=0 ; i<2 ; i++ )*/
{
/*fprintf(DEBUG,"\n-------pat %ld----\n",i);
fprintf(DEBUG,"@ in file : %ld\n",Where);*/
for ( k=0; k<256; k++ ) /* loop on each note for this pattern */
{
/*fprintf(DEBUG,"[%-4ld] %2x-%2x-%2x\n",k,in_data[Where],in_data[Where+1],in_data[Where+2]); */
Whatever[k*4] = poss[in_data[Where]&0x7f][0];
/*Whatever[k*4] &= in_data[Where]&0x80;*/ /* not sure .. never seen */
Whatever[k*4+1] = poss[in_data[Where]&0x7f][1];
Whatever[k*4+2] = in_data[Where+1];
Whatever[k*4+3] = in_data[Where+2];
Where += 3;
}
/*fprintf(DEBUG,"\nEND OF LOOP ?!?\n");*/
fwrite ( Whatever , 1024 , 1 , out );
}
free ( Whatever );
fwrite ( &in_data[Where] , Total_Sample_Size , 1 , out );
Crap ( " Skizzo " , BAD , BAD , out );
/* fflush ( DEBUG );
fclose ( DEBUG );*/
fflush ( out );
fclose ( out );
printf ( "done\n" );
return; /* useless ... but */
}
