/*
-Copyright (C) 1999-2007 id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+ Copyright (C) 1999-2007 id Software, Inc. and contributors.
+ For a list of contributors, see the accompanying CONTRIBUTORS file.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-GtkRadiant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ GtkRadiant is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
#include "qdata.h"
#include "inout.h"
-byte *soundtrack;
-char base[32];
+byte *soundtrack;
+char base[32];
/*
-===============================================================================
+ ===============================================================================
-WAV loading
+ WAV loading
-===============================================================================
-*/
+ ===============================================================================
+ */
typedef struct
{
- int rate;
- int width;
- int channels;
- int loopstart;
- int samples;
- int dataofs; // chunk starts this many bytes from file start
+ int rate;
+ int width;
+ int channels;
+ int loopstart;
+ int samples;
+ int dataofs; // chunk starts this many bytes from file start
} wavinfo_t;
-byte *data_p;
-byte *iff_end;
-byte *last_chunk;
-byte *iff_data;
-int iff_chunk_len;
+byte *data_p;
+byte *iff_end;
+byte *last_chunk;
+byte *iff_data;
+int iff_chunk_len;
-int samplecounts[0x10000];
+int samplecounts[0x10000];
-wavinfo_t wavinfo;
+wavinfo_t wavinfo;
-short GetLittleShort(void)
-{
+short GetLittleShort( void ){
short val = 0;
val = *data_p;
- val = val + (*(data_p+1)<<8);
+ val = val + ( *( data_p + 1 ) << 8 );
data_p += 2;
return val;
}
-int GetLittleLong(void)
-{
+int GetLittleLong( void ){
int val = 0;
val = *data_p;
- val = val + (*(data_p+1)<<8);
- val = val + (*(data_p+2)<<16);
- val = val + (*(data_p+3)<<24);
+ val = val + ( *( data_p + 1 ) << 8 );
+ val = val + ( *( data_p + 2 ) << 16 );
+ val = val + ( *( data_p + 3 ) << 24 );
data_p += 4;
return val;
}
-void FindNextChunk(char *name)
-{
- while (1)
+void FindNextChunk( char *name ){
+ while ( 1 )
{
- data_p=last_chunk;
+ data_p = last_chunk;
- if (data_p >= iff_end)
- { // didn't find the chunk
+ if ( data_p >= iff_end ) { // didn't find the chunk
data_p = NULL;
return;
}
-
+
data_p += 4;
iff_chunk_len = GetLittleLong();
- if (iff_chunk_len < 0)
- {
+ if ( iff_chunk_len < 0 ) {
data_p = NULL;
return;
}
// if (iff_chunk_len > 1024*1024)
// Sys_Error ("FindNextChunk: %i length is past the 1 meg sanity limit", iff_chunk_len);
data_p -= 8;
- last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );
- if (!strncmp(data_p, name, 4))
+ last_chunk = data_p + 8 + ( ( iff_chunk_len + 1 ) & ~1 );
+ if ( !strncmp( data_p, name, 4 ) ) {
return;
+ }
}
}
-void FindChunk(char *name)
-{
+void FindChunk( char *name ){
last_chunk = iff_data;
- FindNextChunk (name);
+ FindNextChunk( name );
}
-void DumpChunks(void)
-{
- char str[5];
-
+void DumpChunks( void ){
+ char str[5];
+
str[4] = 0;
- data_p=iff_data;
+ data_p = iff_data;
do
{
- memcpy (str, data_p, 4);
+ memcpy( str, data_p, 4 );
data_p += 4;
iff_chunk_len = GetLittleLong();
- printf ("0x%x : %s (%d)\n", (int)(data_p - 4), str, iff_chunk_len);
- data_p += (iff_chunk_len + 1) & ~1;
- } while (data_p < iff_end);
+ printf( "0x%x : %s (%d)\n", (int)( data_p - 4 ), str, iff_chunk_len );
+ data_p += ( iff_chunk_len + 1 ) & ~1;
+ } while ( data_p < iff_end );
}
/*
-============
-GetWavinfo
-============
-*/
-wavinfo_t GetWavinfo (char *name, byte *wav, int wavlength)
-{
- wavinfo_t info;
- int i;
- int format;
- int samples;
-
- memset (&info, 0, sizeof(info));
-
- if (!wav)
+ ============
+ GetWavinfo
+ ============
+ */
+wavinfo_t GetWavinfo( char *name, byte *wav, int wavlength ){
+ wavinfo_t info;
+ int i;
+ int format;
+ int samples;
+
+ memset( &info, 0, sizeof( info ) );
+
+ if ( !wav ) {
return info;
-
+ }
+
iff_data = wav;
iff_end = wav + wavlength;
// find "RIFF" chunk
- FindChunk("RIFF");
- if (!(data_p && !strncmp(data_p+8, "WAVE", 4)))
- {
- printf("Missing RIFF/WAVE chunks\n");
+ FindChunk( "RIFF" );
+ if ( !( data_p && !strncmp( data_p + 8, "WAVE", 4 ) ) ) {
+ printf( "Missing RIFF/WAVE chunks\n" );
return info;
}
iff_data = data_p + 12;
// DumpChunks ();
- FindChunk("fmt ");
- if (!data_p)
- {
- printf("Missing fmt chunk\n");
+ FindChunk( "fmt " );
+ if ( !data_p ) {
+ printf( "Missing fmt chunk\n" );
return info;
}
data_p += 8;
format = GetLittleShort();
- if (format != 1)
- {
- printf("Microsoft PCM format only\n");
+ if ( format != 1 ) {
+ printf( "Microsoft PCM format only\n" );
return info;
}
info.channels = GetLittleShort();
info.rate = GetLittleLong();
- data_p += 4+2;
+ data_p += 4 + 2;
info.width = GetLittleShort() / 8;
// get cue chunk
- FindChunk("cue ");
- if (data_p)
- {
+ FindChunk( "cue " );
+ if ( data_p ) {
data_p += 32;
info.loopstart = GetLittleLong();
// Com_Printf("loopstart=%d\n", sfx->loopstart);
- // if the next chunk is a LIST chunk, look for a cue length marker
- FindNextChunk ("LIST");
- if (data_p)
- {
- if (!strncmp (data_p + 28, "mark", 4))
- { // this is not a proper parse, but it works with cooledit...
+ // if the next chunk is a LIST chunk, look for a cue length marker
+ FindNextChunk( "LIST" );
+ if ( data_p ) {
+ if ( !strncmp( data_p + 28, "mark", 4 ) ) { // this is not a proper parse, but it works with cooledit...
data_p += 24;
- i = GetLittleLong (); // samples in loop
+ i = GetLittleLong(); // samples in loop
info.samples = info.loopstart + i;
}
}
}
- else
+ else{
info.loopstart = -1;
+ }
// find data chunk
- FindChunk("data");
- if (!data_p)
- {
- printf("Missing data chunk\n");
+ FindChunk( "data" );
+ if ( !data_p ) {
+ printf( "Missing data chunk\n" );
return info;
}
data_p += 4;
- samples = GetLittleLong ();
+ samples = GetLittleLong();
- if (info.samples)
- {
- if (samples < info.samples)
- Error ("Sound %s has a bad loop length", name);
+ if ( info.samples ) {
+ if ( samples < info.samples ) {
+ Error( "Sound %s has a bad loop length", name );
+ }
}
- else
+ else{
info.samples = samples;
+ }
info.dataofs = data_p - wav;
//=====================================================================
/*
-==============
-LoadSoundtrack
-==============
-*/
-void LoadSoundtrack (void)
-{
- char name[1024];
- FILE *f;
- int len;
- int i, val, j;
+ ==============
+ LoadSoundtrack
+ ==============
+ */
+void LoadSoundtrack( void ){
+ char name[1024];
+ FILE *f;
+ int len;
+ int i, val, j;
soundtrack = NULL;
- sprintf (name, "%svideo/%s/%s.wav", gamedir, base, base);
- printf ("%s\n", name);
- f = fopen (name, "rb");
- if (!f)
- {
- printf ("no soundtrack for %s\n", base);
+ sprintf( name, "%svideo/%s/%s.wav", gamedir, base, base );
+ printf( "%s\n", name );
+ f = fopen( name, "rb" );
+ if ( !f ) {
+ printf( "no soundtrack for %s\n", base );
return;
}
- len = Q_filelength(f);
- soundtrack = malloc(len);
- fread (soundtrack, 1, len, f);
- fclose (f);
+ len = Q_filelength( f );
+ soundtrack = malloc( len );
+ fread( soundtrack, 1, len, f );
+ fclose( f );
- wavinfo = GetWavinfo (name, soundtrack, len);
+ wavinfo = GetWavinfo( name, soundtrack, len );
// count samples for compression
- memset (samplecounts, 0, sizeof(samplecounts));
+ memset( samplecounts, 0, sizeof( samplecounts ) );
- j = wavinfo.samples/2;
- for (i=0 ; i<j ; i++)
+ j = wavinfo.samples / 2;
+ for ( i = 0 ; i < j ; i++ )
{
- val = ((unsigned short *)( soundtrack + wavinfo.dataofs))[i];
+ val = ( (unsigned short *)( soundtrack + wavinfo.dataofs ) )[i];
samplecounts[val]++;
}
val = 0;
- for (i=0 ; i<0x10000 ; i++)
- if (samplecounts[i])
+ for ( i = 0 ; i < 0x10000 ; i++ )
+ if ( samplecounts[i] ) {
val++;
+ }
- printf ("%i unique sample values\n", val);
+ printf( "%i unique sample values\n", val );
}
/*
-==================
-WriteSound
-==================
-*/
-void WriteSound (FILE *output, int frame)
-{
- int start, end;
- int count;
- int empty = 0;
- int i;
- int sample;
- int width;
+ ==================
+ WriteSound
+ ==================
+ */
+void WriteSound( FILE *output, int frame ){
+ int start, end;
+ int count;
+ int empty = 0;
+ int i;
+ int sample;
+ int width;
width = wavinfo.width * wavinfo.channels;
- start = frame*wavinfo.rate/14;
- end = (frame+1)*wavinfo.rate/14;
+ start = frame * wavinfo.rate / 14;
+ end = ( frame + 1 ) * wavinfo.rate / 14;
count = end - start;
- for (i=0 ; i<count ; i++)
+ for ( i = 0 ; i < count ; i++ )
{
- sample = start+i;
- if (sample > wavinfo.samples || !soundtrack)
- fwrite (&empty, 1, width, output);
- else
- fwrite (soundtrack + wavinfo.dataofs + sample*width, 1, width,output);
+ sample = start + i;
+ if ( sample > wavinfo.samples || !soundtrack ) {
+ fwrite( &empty, 1, width, output );
+ }
+ else{
+ fwrite( soundtrack + wavinfo.dataofs + sample * width, 1, width,output );
+ }
}
}
//==========================================================================
/*
-==================
-MTF
-==================
-*/
-cblock_t MTF (cblock_t in)
-{
- int i, j, b, code;
- byte *out_p;
- int index[256];
- cblock_t out;
-
- out_p = out.data = malloc(in.count + 4);
+ ==================
+ MTF
+ ==================
+ */
+cblock_t MTF( cblock_t in ){
+ int i, j, b, code;
+ byte *out_p;
+ int index[256];
+ cblock_t out;
+
+ out_p = out.data = malloc( in.count + 4 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
- for (i=0 ; i<256 ; i++)
+ for ( i = 0 ; i < 256 ; i++ )
index[i] = i;
- for (i=0 ; i<in.count ; i++)
+ for ( i = 0 ; i < in.count ; i++ )
{
b = in.data[i];
code = index[b];
*out_p++ = code;
-
+
// shuffle b indexes to 0
- for (j=0 ; j<256 ; j++)
- if (index[j] < code)
+ for ( j = 0 ; j < 256 ; j++ )
+ if ( index[j] < code ) {
index[j]++;
+ }
index[b] = 0;
}
//==========================================================================
-int bwt_size;
-byte *bwt_data;
+int bwt_size;
+byte *bwt_data;
-int bwtCompare (const void *elem1, const void *elem2)
-{
- int i;
- int i1, i2;
- int b1, b2;
+int bwtCompare( const void *elem1, const void *elem2 ){
+ int i;
+ int i1, i2;
+ int b1, b2;
i1 = *(int *)elem1;
i2 = *(int *)elem2;
- for (i=0 ; i<bwt_size ; i++)
+ for ( i = 0 ; i < bwt_size ; i++ )
{
b1 = bwt_data[i1];
b2 = bwt_data[i2];
- if (b1 < b2)
+ if ( b1 < b2 ) {
return -1;
- if (b1 > b2)
+ }
+ if ( b1 > b2 ) {
return 1;
- if (++i1 == bwt_size)
+ }
+ if ( ++i1 == bwt_size ) {
i1 = 0;
- if (++i2 == bwt_size)
+ }
+ if ( ++i2 == bwt_size ) {
i2 = 0;
+ }
}
return 0;
}
/*
-==================
-BWT
-==================
-*/
-cblock_t BWT (cblock_t in)
-{
- int *sorted;
- int i;
- byte *out_p;
- cblock_t out;
+ ==================
+ BWT
+ ==================
+ */
+cblock_t BWT( cblock_t in ){
+ int *sorted;
+ int i;
+ byte *out_p;
+ cblock_t out;
bwt_size = in.count;
bwt_data = in.data;
- sorted = malloc(in.count*sizeof(*sorted));
- for (i=0 ; i<in.count ; i++)
+ sorted = malloc( in.count * sizeof( *sorted ) );
+ for ( i = 0 ; i < in.count ; i++ )
sorted[i] = i;
- qsort (sorted, in.count, sizeof(*sorted), bwtCompare);
+ qsort( sorted, in.count, sizeof( *sorted ), bwtCompare );
- out_p = out.data = malloc(in.count + 8);
+ out_p = out.data = malloc( in.count + 8 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
// write head index
- for (i=0 ; i<in.count ; i++)
- if (sorted[i] == 0)
+ for ( i = 0 ; i < in.count ; i++ )
+ if ( sorted[i] == 0 ) {
break;
- *out_p++ = i&255;
- *out_p++ = (i>>8)&255;
- *out_p++ = (i>>16)&255;
- *out_p++ = (i>>24)&255;
+ }
+ *out_p++ = i & 255;
+ *out_p++ = ( i >> 8 ) & 255;
+ *out_p++ = ( i >> 16 ) & 255;
+ *out_p++ = ( i >> 24 ) & 255;
// write the L column
- for (i=0 ; i<in.count ; i++)
- *out_p++ = in.data[(sorted[i]+in.count-1)%in.count];
+ for ( i = 0 ; i < in.count ; i++ )
+ *out_p++ = in.data[( sorted[i] + in.count - 1 ) % in.count];
- free (sorted);
+ free( sorted );
out.count = out_p - out.data;
typedef struct hnode_s
{
- int count;
- qboolean used;
- int children[2];
+ int count;
+ qboolean used;
+ int children[2];
} hnode_t;
-int numhnodes;
-hnode_t hnodes[512];
-unsigned charbits[256];
-int charbitscount[256];
+int numhnodes;
+hnode_t hnodes[512];
+unsigned charbits[256];
+int charbitscount[256];
-int SmallestNode (void)
-{
- int i;
- int best, bestnode;
+int SmallestNode( void ){
+ int i;
+ int best, bestnode;
best = 99999999;
bestnode = -1;
- for (i=0 ; i<numhnodes ; i++)
+ for ( i = 0 ; i < numhnodes ; i++ )
{
- if (hnodes[i].used)
+ if ( hnodes[i].used ) {
continue;
- if (!hnodes[i].count)
+ }
+ if ( !hnodes[i].count ) {
continue;
- if (hnodes[i].count < best)
- {
+ }
+ if ( hnodes[i].count < best ) {
best = hnodes[i].count;
bestnode = i;
}
}
- if (bestnode == -1)
+ if ( bestnode == -1 ) {
return -1;
+ }
hnodes[bestnode].used = true;
return bestnode;
}
-void BuildChars (int nodenum, unsigned bits, int bitcount)
-{
- hnode_t *node;
+void BuildChars( int nodenum, unsigned bits, int bitcount ){
+ hnode_t *node;
- if (nodenum < 256)
- {
- if (bitcount > 32)
- Error ("bitcount > 32");
+ if ( nodenum < 256 ) {
+ if ( bitcount > 32 ) {
+ Error( "bitcount > 32" );
+ }
charbits[nodenum] = bits;
charbitscount[nodenum] = bitcount;
return;
node = &hnodes[nodenum];
bits <<= 1;
- BuildChars (node->children[0], bits, bitcount+1);
+ BuildChars( node->children[0], bits, bitcount + 1 );
bits |= 1;
- BuildChars (node->children[1], bits, bitcount+1);
+ BuildChars( node->children[1], bits, bitcount + 1 );
}
/*
-==================
-Huffman
-==================
-*/
-cblock_t Huffman (cblock_t in)
-{
- int i;
- hnode_t *node;
- int outbits, c;
- unsigned bits;
- byte *out_p;
- cblock_t out;
- int max, maxchar;
+ ==================
+ Huffman
+ ==================
+ */
+cblock_t Huffman( cblock_t in ){
+ int i;
+ hnode_t *node;
+ int outbits, c;
+ unsigned bits;
+ byte *out_p;
+ cblock_t out;
+ int max, maxchar;
// count
- memset (hnodes, 0, sizeof(hnodes));
- for (i=0 ; i<in.count ; i++)
+ memset( hnodes, 0, sizeof( hnodes ) );
+ for ( i = 0 ; i < in.count ; i++ )
hnodes[in.data[i]].count++;
// normalize counts
max = 0;
maxchar = 0;
- for (i=0 ; i<256 ; i++)
+ for ( i = 0 ; i < 256 ; i++ )
{
- if (hnodes[i].count > max)
- {
+ if ( hnodes[i].count > max ) {
max = hnodes[i].count;
maxchar = i;
}
}
- if (max == 0)
- Error ("Huffman: max == 0");
+ if ( max == 0 ) {
+ Error( "Huffman: max == 0" );
+ }
- for (i=0 ; i<256 ; i++)
+ for ( i = 0 ; i < 256 ; i++ )
{
- hnodes[i].count = (hnodes[i].count*255+max-1) / max;
+ hnodes[i].count = ( hnodes[i].count * 255 + max - 1 ) / max;
}
// build the nodes
numhnodes = 256;
- while (numhnodes != 511)
+ while ( numhnodes != 511 )
{
node = &hnodes[numhnodes];
// pick two lowest counts
- node->children[0] = SmallestNode ();
- if (node->children[0] == -1)
- break; // no more
+ node->children[0] = SmallestNode();
+ if ( node->children[0] == -1 ) {
+ break; // no more
- node->children[1] = SmallestNode ();
- if (node->children[1] == -1)
- {
- if (node->children[0] != numhnodes-1)
- Error ("Bad smallestnode");
+ }
+ node->children[1] = SmallestNode();
+ if ( node->children[1] == -1 ) {
+ if ( node->children[0] != numhnodes - 1 ) {
+ Error( "Bad smallestnode" );
+ }
break;
}
- node->count = hnodes[node->children[0]].count +
- hnodes[node->children[1]].count;
+ node->count = hnodes[node->children[0]].count +
+ hnodes[node->children[1]].count;
numhnodes++;
}
- BuildChars (numhnodes-1, 0, 0);
+ BuildChars( numhnodes - 1, 0, 0 );
- out_p = out.data = malloc(in.count*2 + 1024);
- memset (out_p, 0, in.count*2+1024);
+ out_p = out.data = malloc( in.count * 2 + 1024 );
+ memset( out_p, 0, in.count * 2 + 1024 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
// save out the 256 normalized counts so the tree can be recreated
- for (i=0 ; i<256 ; i++)
+ for ( i = 0 ; i < 256 ; i++ )
*out_p++ = hnodes[i].count;
// write bits
outbits = 0;
- for (i=0 ; i<in.count ; i++)
+ for ( i = 0 ; i < in.count ; i++ )
{
c = charbitscount[in.data[i]];
bits = charbits[in.data[i]];
- while (c)
+ while ( c )
{
c--;
- if (bits & (1<<c))
- out_p[outbits>>3] |= 1<<(outbits&7);
+ if ( bits & ( 1 << c ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
outbits++;
}
}
- out_p += (outbits+7)>>3;
+ out_p += ( outbits + 7 ) >> 3;
out.count = out_p - out.data;
//==========================================================================
/*
-==================
-RLE
-==================
-*/
-#define RLE_CODE 0xe8
-#define RLE_TRIPPLE 0xe9
+ ==================
+ RLE
+ ==================
+ */
+#define RLE_CODE 0xe8
+#define RLE_TRIPPLE 0xe9
-int rle_counts[256];
-int rle_bytes[256];
+int rle_counts[256];
+int rle_bytes[256];
-cblock_t RLE (cblock_t in)
-{
- int i;
- byte *out_p;
- int val;
- int repeat;
- cblock_t out;
+cblock_t RLE( cblock_t in ){
+ int i;
+ byte *out_p;
+ int val;
+ int repeat;
+ cblock_t out;
- out_p = out.data = malloc (in.count*2);
+ out_p = out.data = malloc( in.count * 2 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
- for (i=0 ; i<in.count ; )
+ for ( i = 0 ; i < in.count ; )
{
val = in.data[i];
rle_bytes[val]++;
repeat = 1;
i++;
- while (i<in.count && repeat < 255 && in.data[i] == val)
+ while ( i < in.count && repeat < 255 && in.data[i] == val )
{
repeat++;
i++;
}
-if (repeat < 256)
-rle_counts[repeat]++;
- if (repeat > 3 || val == RLE_CODE)
- {
+ if ( repeat < 256 ) {
+ rle_counts[repeat]++;
+ }
+ if ( repeat > 3 || val == RLE_CODE ) {
*out_p++ = RLE_CODE;
*out_p++ = val;
*out_p++ = repeat;
}
else
{
- while (repeat--)
+ while ( repeat-- )
*out_p++ = val;
}
}
//==========================================================================
-unsigned lzss_head[256];
-unsigned lzss_next[0x20000];
+unsigned lzss_head[256];
+unsigned lzss_next[0x20000];
/*
-==================
-LZSS
-==================
-*/
-#define BACK_WINDOW 0x10000
-#define BACK_BITS 16
-#define FRONT_WINDOW 16
-#define FRONT_BITS 4
-cblock_t LZSS (cblock_t in)
-{
- int i;
- byte *out_p;
- cblock_t out;
- int val;
- int j, start, max;
- int bestlength, beststart;
- int outbits;
-
-if (in.count >= sizeof(lzss_next)/4)
-Error ("LZSS: too big");
+ ==================
+ LZSS
+ ==================
+ */
+#define BACK_WINDOW 0x10000
+#define BACK_BITS 16
+#define FRONT_WINDOW 16
+#define FRONT_BITS 4
+cblock_t LZSS( cblock_t in ){
+ int i;
+ byte *out_p;
+ cblock_t out;
+ int val;
+ int j, start, max;
+ int bestlength, beststart;
+ int outbits;
+
+ if ( in.count >= sizeof( lzss_next ) / 4 ) {
+ Error( "LZSS: too big" );
+ }
- memset (lzss_head, -1, sizeof(lzss_head));
+ memset( lzss_head, -1, sizeof( lzss_head ) );
- out_p = out.data = malloc (in.count*2);
- memset (out.data, 0, in.count*2);
+ out_p = out.data = malloc( in.count * 2 );
+ memset( out.data, 0, in.count * 2 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
outbits = 0;
- for (i=0 ; i<in.count ; )
+ for ( i = 0 ; i < in.count ; )
{
val = in.data[i];
#if 1
beststart = 0;
max = FRONT_WINDOW;
- if (i + max > in.count)
+ if ( i + max > in.count ) {
max = in.count - i;
+ }
start = lzss_head[val];
- while (start != -1 && start >= i-BACK_WINDOW)
- {
+ while ( start != -1 && start >= i - BACK_WINDOW )
+ {
// count match length
- for (j=0 ; j<max ; j++)
- if (in.data[start+j] != in.data[i+j])
+ for ( j = 0 ; j < max ; j++ )
+ if ( in.data[start + j] != in.data[i + j] ) {
break;
- if (j > bestlength)
- {
+ }
+ if ( j > bestlength ) {
bestlength = j;
beststart = start;
}
// slow simple search
// search for a match
max = FRONT_WINDOW;
- if (i + max > in.count)
+ if ( i + max > in.count ) {
max = in.count - i;
+ }
start = i - BACK_WINDOW;
- if (start < 0)
+ if ( start < 0 ) {
start = 0;
+ }
bestlength = 0;
beststart = 0;
- for ( ; start < i ; start++)
+ for ( ; start < i ; start++ )
{
- if (in.data[start] != val)
+ if ( in.data[start] != val ) {
continue;
+ }
// count match length
- for (j=0 ; j<max ; j++)
- if (in.data[start+j] != in.data[i+j])
+ for ( j = 0 ; j < max ; j++ )
+ if ( in.data[start + j] != in.data[i + j] ) {
break;
- if (j > bestlength)
- {
+ }
+ if ( j > bestlength ) {
bestlength = j;
beststart = start;
}
}
#endif
- beststart = BACK_WINDOW - (i-beststart);
+ beststart = BACK_WINDOW - ( i - beststart );
- if (bestlength < 3)
- { // output a single char
+ if ( bestlength < 3 ) { // output a single char
bestlength = 1;
- out_p[outbits>>3] |= 1<<(outbits&7); // set bit to mark char
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 ); // set bit to mark char
outbits++;
- for (j=0 ; j<8 ; j++, outbits++)
- if (val & (1<<j) )
- out_p[outbits>>3] |= 1<<(outbits&7);
+ for ( j = 0 ; j < 8 ; j++, outbits++ )
+ if ( val & ( 1 << j ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
}
else
- { // output a phrase
- outbits++; // leave a 0 bit to mark phrase
- for (j=0 ; j<BACK_BITS ; j++, outbits++)
- if (beststart & (1<<j) )
- out_p[outbits>>3] |= 1<<(outbits&7);
- for (j=0 ; j<FRONT_BITS ; j++, outbits++)
- if (bestlength & (1<<j) )
- out_p[outbits>>3] |= 1<<(outbits&7);
+ { // output a phrase
+ outbits++; // leave a 0 bit to mark phrase
+ for ( j = 0 ; j < BACK_BITS ; j++, outbits++ )
+ if ( beststart & ( 1 << j ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
+ for ( j = 0 ; j < FRONT_BITS ; j++, outbits++ )
+ if ( bestlength & ( 1 << j ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
}
- while (bestlength--)
+ while ( bestlength-- )
{
val = in.data[i];
lzss_next[i] = lzss_head[val];
}
}
- out_p += (outbits+7)>>3;
+ out_p += ( outbits + 7 ) >> 3;
out.count = out_p - out.data;
return out;
}
//==========================================================================
-#define MIN_REPT 15
-#define MAX_REPT 0
-#define HUF_TOKENS (256+MAX_REPT)
+#define MIN_REPT 15
+#define MAX_REPT 0
+#define HUF_TOKENS ( 256 + MAX_REPT )
-unsigned charbits1[256][HUF_TOKENS];
-int charbitscount1[256][HUF_TOKENS];
+unsigned charbits1[256][HUF_TOKENS];
+int charbitscount1[256][HUF_TOKENS];
-hnode_t hnodes1[256][HUF_TOKENS*2];
-int numhnodes1[256];
+hnode_t hnodes1[256][HUF_TOKENS * 2];
+int numhnodes1[256];
-int order0counts[256];
+int order0counts[256];
/*
-==================
-SmallestNode1
-==================
-*/
-int SmallestNode1 (hnode_t *hnodes, int numhnodes)
-{
- int i;
- int best, bestnode;
+ ==================
+ SmallestNode1
+ ==================
+ */
+int SmallestNode1( hnode_t *hnodes, int numhnodes ){
+ int i;
+ int best, bestnode;
best = 99999999;
bestnode = -1;
- for (i=0 ; i<numhnodes ; i++)
+ for ( i = 0 ; i < numhnodes ; i++ )
{
- if (hnodes[i].used)
+ if ( hnodes[i].used ) {
continue;
- if (!hnodes[i].count)
+ }
+ if ( !hnodes[i].count ) {
continue;
- if (hnodes[i].count < best)
- {
+ }
+ if ( hnodes[i].count < best ) {
best = hnodes[i].count;
bestnode = i;
}
}
- if (bestnode == -1)
+ if ( bestnode == -1 ) {
return -1;
+ }
hnodes[bestnode].used = true;
return bestnode;
/*
-==================
-BuildChars1
-==================
-*/
-void BuildChars1 (int prev, int nodenum, unsigned bits, int bitcount)
-{
- hnode_t *node;
-
- if (nodenum < HUF_TOKENS)
- {
- if (bitcount > 32)
- Error ("bitcount > 32");
+ ==================
+ BuildChars1
+ ==================
+ */
+void BuildChars1( int prev, int nodenum, unsigned bits, int bitcount ){
+ hnode_t *node;
+
+ if ( nodenum < HUF_TOKENS ) {
+ if ( bitcount > 32 ) {
+ Error( "bitcount > 32" );
+ }
charbits1[prev][nodenum] = bits;
charbitscount1[prev][nodenum] = bitcount;
return;
node = &hnodes1[prev][nodenum];
bits <<= 1;
- BuildChars1 (prev, node->children[0], bits, bitcount+1);
+ BuildChars1( prev, node->children[0], bits, bitcount + 1 );
bits |= 1;
- BuildChars1 (prev, node->children[1], bits, bitcount+1);
+ BuildChars1( prev, node->children[1], bits, bitcount + 1 );
}
/*
-==================
-BuildTree1
-==================
-*/
-void BuildTree1 (int prev)
-{
- hnode_t *node, *nodebase;
- int numhnodes;
+ ==================
+ BuildTree1
+ ==================
+ */
+void BuildTree1( int prev ){
+ hnode_t *node, *nodebase;
+ int numhnodes;
// build the nodes
numhnodes = HUF_TOKENS;
nodebase = hnodes1[prev];
- while (1)
+ while ( 1 )
{
node = &nodebase[numhnodes];
// pick two lowest counts
- node->children[0] = SmallestNode1 (nodebase, numhnodes);
- if (node->children[0] == -1)
- break; // no more
+ node->children[0] = SmallestNode1( nodebase, numhnodes );
+ if ( node->children[0] == -1 ) {
+ break; // no more
- node->children[1] = SmallestNode1 (nodebase, numhnodes);
- if (node->children[1] == -1)
+ }
+ node->children[1] = SmallestNode1( nodebase, numhnodes );
+ if ( node->children[1] == -1 ) {
break;
+ }
- node->count = nodebase[node->children[0]].count +
- nodebase[node->children[1]].count;
+ node->count = nodebase[node->children[0]].count +
+ nodebase[node->children[1]].count;
numhnodes++;
}
- numhnodes1[prev] = numhnodes-1;
- BuildChars1 (prev, numhnodes-1, 0, 0);
+ numhnodes1[prev] = numhnodes - 1;
+ BuildChars1( prev, numhnodes - 1, 0, 0 );
}
/*
-==================
-Huffman1_Count
-==================
-*/
-void Huffman1_Count (cblock_t in)
-{
- int i;
- int prev;
- int v;
- int rept;
+ ==================
+ Huffman1_Count
+ ==================
+ */
+void Huffman1_Count( cblock_t in ){
+ int i;
+ int prev;
+ int v;
+ int rept;
prev = 0;
- for (i=0 ; i<in.count ; i++)
+ for ( i = 0 ; i < in.count ; i++ )
{
v = in.data[i];
order0counts[v]++;
hnodes1[prev][v].count++;
prev = v;
#if 1
- for (rept=1 ; i+rept < in.count && rept < MAX_REPT ; rept++)
- if (in.data[i+rept] != v)
+ for ( rept = 1 ; i + rept < in.count && rept < MAX_REPT ; rept++ )
+ if ( in.data[i + rept] != v ) {
break;
- if (rept > MIN_REPT)
- {
- hnodes1[prev][255+rept].count++;
- i += rept-1;
+ }
+ if ( rept > MIN_REPT ) {
+ hnodes1[prev][255 + rept].count++;
+ i += rept - 1;
}
#endif
}
/*
-==================
-Huffman1_Build
-==================
-*/
-byte scaled[256][HUF_TOKENS];
-void Huffman1_Build (FILE *f)
-{
- int i, j, v;
- int max;
- int total;
-
- for (i=0 ; i<256 ; i++)
+ ==================
+ Huffman1_Build
+ ==================
+ */
+byte scaled[256][HUF_TOKENS];
+void Huffman1_Build( FILE *f ){
+ int i, j, v;
+ int max;
+ int total;
+
+ for ( i = 0 ; i < 256 ; i++ )
{
// normalize and save the counts
max = 0;
- for (j=0 ; j<HUF_TOKENS ; j++)
+ for ( j = 0 ; j < HUF_TOKENS ; j++ )
{
- if (hnodes1[i][j].count > max)
+ if ( hnodes1[i][j].count > max ) {
max = hnodes1[i][j].count;
+ }
}
- if (max == 0)
+ if ( max == 0 ) {
max = 1;
+ }
total = 0;
- for (j=0 ; j<HUF_TOKENS ; j++)
- { // easy to overflow 32 bits here!
- v = (hnodes1[i][j].count*(double)255+max-1)/max;
- if (v > 255)
- Error ("v > 255");
+ for ( j = 0 ; j < HUF_TOKENS ; j++ )
+ { // easy to overflow 32 bits here!
+ v = ( hnodes1[i][j].count * (double)255 + max - 1 ) / max;
+ if ( v > 255 ) {
+ Error( "v > 255" );
+ }
scaled[i][j] = hnodes1[i][j].count = v;
- if (v)
+ if ( v ) {
total++;
+ }
}
- if (total == 1)
- { // must have two tokens
- if (!scaled[i][0])
+ if ( total == 1 ) { // must have two tokens
+ if ( !scaled[i][0] ) {
scaled[i][0] = hnodes1[i][0].count = 1;
- else
+ }
+ else{
scaled[i][1] = hnodes1[i][1].count = 1;
+ }
}
- BuildTree1 (i);
+ BuildTree1( i );
}
#if 0
// count up the total bits
total = 0;
- for (i=0 ; i<256 ; i++)
- for (j=0 ; j<256 ; j++)
+ for ( i = 0 ; i < 256 ; i++ )
+ for ( j = 0 ; j < 256 ; j++ )
total += charbitscount1[i][j] * hnodes1[i][j].count;
- total = (total+7)/8;
- printf ("%i bytes huffman1 compressed\n", total);
+ total = ( total + 7 ) / 8;
+ printf( "%i bytes huffman1 compressed\n", total );
#endif
- fwrite (scaled, 1, sizeof(scaled), f);
+ fwrite( scaled, 1, sizeof( scaled ), f );
}
/*
-==================
-Huffman1
-
-Order 1 compression with pre-built table
-==================
-*/
-cblock_t Huffman1 (cblock_t in)
-{
- int i;
- int outbits, c;
- unsigned bits;
- byte *out_p;
- cblock_t out;
- int prev;
- int v;
- int rept;
-
- out_p = out.data = malloc(in.count*2 + 1024);
- memset (out_p, 0, in.count*2+1024);
+ ==================
+ Huffman1
+
+ Order 1 compression with pre-built table
+ ==================
+ */
+cblock_t Huffman1( cblock_t in ){
+ int i;
+ int outbits, c;
+ unsigned bits;
+ byte *out_p;
+ cblock_t out;
+ int prev;
+ int v;
+ int rept;
+
+ out_p = out.data = malloc( in.count * 2 + 1024 );
+ memset( out_p, 0, in.count * 2 + 1024 );
// write count
- *out_p++ = in.count&255;
- *out_p++ = (in.count>>8)&255;
- *out_p++ = (in.count>>16)&255;
- *out_p++ = (in.count>>24)&255;
+ *out_p++ = in.count & 255;
+ *out_p++ = ( in.count >> 8 ) & 255;
+ *out_p++ = ( in.count >> 16 ) & 255;
+ *out_p++ = ( in.count >> 24 ) & 255;
// write bits
outbits = 0;
prev = 0;
- for (i=0 ; i<in.count ; i++)
+ for ( i = 0 ; i < in.count ; i++ )
{
v = in.data[i];
c = charbitscount1[prev][v];
bits = charbits1[prev][v];
- if (!c)
- Error ("!bits");
- while (c)
+ if ( !c ) {
+ Error( "!bits" );
+ }
+ while ( c )
{
c--;
- if (bits & (1<<c))
- out_p[outbits>>3] |= 1<<(outbits&7);
+ if ( bits & ( 1 << c ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
outbits++;
}
prev = v;
#if 1
// check for repeat encodes
- for (rept=1 ; i+rept < in.count && rept < MAX_REPT ; rept++)
- if (in.data[i+rept] != v)
+ for ( rept = 1 ; i + rept < in.count && rept < MAX_REPT ; rept++ )
+ if ( in.data[i + rept] != v ) {
break;
- if (rept > MIN_REPT)
- {
- c = charbitscount1[prev][255+rept];
- bits = charbits1[prev][255+rept];
- if (!c)
- Error ("!bits");
- while (c)
+ }
+ if ( rept > MIN_REPT ) {
+ c = charbitscount1[prev][255 + rept];
+ bits = charbits1[prev][255 + rept];
+ if ( !c ) {
+ Error( "!bits" );
+ }
+ while ( c )
{
c--;
- if (bits & (1<<c))
- out_p[outbits>>3] |= 1<<(outbits&7);
+ if ( bits & ( 1 << c ) ) {
+ out_p[outbits >> 3] |= 1 << ( outbits & 7 );
+ }
outbits++;
}
- i += rept-1;
+ i += rept - 1;
}
#endif
}
- out_p += (outbits+7)>>3;
+ out_p += ( outbits + 7 ) >> 3;
out.count = out_p - out.data;
/*
-===================
-LoadFrame
-===================
-*/
-cblock_t LoadFrame (char *base, int frame, int digits, byte **palette)
-{
- int ten3, ten2, ten1, ten0;
- cblock_t in;
- int width, height;
- char name[1024];
- FILE *f;
+ ===================
+ LoadFrame
+ ===================
+ */
+cblock_t LoadFrame( char *base, int frame, int digits, byte **palette ){
+ int ten3, ten2, ten1, ten0;
+ cblock_t in;
+ int width, height;
+ char name[1024];
+ FILE *f;
in.data = NULL;
in.count = -1;
- ten3 = frame/1000;
- ten2 = (frame-ten3*1000)/100;
- ten1 = (frame-ten3*1000-ten2*100)/10;
- ten0 = frame%10;
+ ten3 = frame / 1000;
+ ten2 = ( frame - ten3 * 1000 ) / 100;
+ ten1 = ( frame - ten3 * 1000 - ten2 * 100 ) / 10;
+ ten0 = frame % 10;
- if (digits == 4)
- sprintf (name, "%svideo/%s/%s%i%i%i%i.pcx", gamedir, base, base, ten3, ten2, ten1, ten0);
- else
- sprintf (name, "%svideo/%s/%s%i%i%i.pcx", gamedir, base, base, ten2, ten1, ten0);
+ if ( digits == 4 ) {
+ sprintf( name, "%svideo/%s/%s%i%i%i%i.pcx", gamedir, base, base, ten3, ten2, ten1, ten0 );
+ }
+ else{
+ sprintf( name, "%svideo/%s/%s%i%i%i.pcx", gamedir, base, base, ten2, ten1, ten0 );
+ }
- f = fopen(name, "rb");
- if (!f)
- {
+ f = fopen( name, "rb" );
+ if ( !f ) {
in.data = NULL;
return in;
}
- fclose (f);
+ fclose( f );
- printf ("%s\n", name);
- Load256Image (name, &in.data, palette, &width, &height);
- in.count = width*height;
+ printf( "%s\n", name );
+ Load256Image( name, &in.data, palette, &width, &height );
+ in.count = width * height;
// FIXME: map 0 and 255!
#if 0
// rle compress
- rle = RLE(in);
- free (in.data);
+ rle = RLE( in );
+ free( in.data );
return rle;
#endif
}
/*
-===============
-Cmd_Video
-
-video <directory> <framedigits>
-===============
-*/
-void Cmd_Video (void)
-{
- char savename[1024];
- char name[1024];
- FILE *output;
- int startframe, frame;
- byte *palette;
- int width, height;
- byte current_palette[768];
- int command;
- int i;
- int digits;
- cblock_t in, huffman;
- int swap;
-
-
- GetToken (false);
- strcpy (base, token);
- if (g_release)
- {
+ ===============
+ Cmd_Video
+
+ video <directory> <framedigits>
+ ===============
+ */
+void Cmd_Video( void ){
+ char savename[1024];
+ char name[1024];
+ FILE *output;
+ int startframe, frame;
+ byte *palette;
+ int width, height;
+ byte current_palette[768];
+ int command;
+ int i;
+ int digits;
+ cblock_t in, huffman;
+ int swap;
+
+
+ GetToken( false );
+ strcpy( base, token );
+ if ( g_release ) {
// sprintf (savename, "video/%s.cin", token);
// ReleaseFile (savename);
return;
}
- GetToken (false);
- digits = atoi(token);
+ GetToken( false );
+ digits = atoi( token );
// optionally skip frames
- if (TokenAvailable ())
- {
- GetToken (false);
- startframe = atoi(token);
+ if ( TokenAvailable() ) {
+ GetToken( false );
+ startframe = atoi( token );
+ }
+ else{
+ startframe = 0;
}
- else
- startframe=0;
- sprintf (savename, "%svideo/%s.cin", gamedir, base);
+ sprintf( savename, "%svideo/%s.cin", gamedir, base );
// clear stuff
- memset (charbits1, 0, sizeof(charbits1));
- memset (charbitscount1, 0, sizeof(charbitscount1));
- memset (hnodes1, 0, sizeof(hnodes1));
- memset (numhnodes1, 0, sizeof(numhnodes1));
- memset (order0counts, 0, sizeof(order0counts));
+ memset( charbits1, 0, sizeof( charbits1 ) );
+ memset( charbitscount1, 0, sizeof( charbitscount1 ) );
+ memset( hnodes1, 0, sizeof( hnodes1 ) );
+ memset( numhnodes1, 0, sizeof( numhnodes1 ) );
+ memset( order0counts, 0, sizeof( order0counts ) );
// load the entire sound wav file if present
- LoadSoundtrack ();
+ LoadSoundtrack();
- if (digits == 4)
- sprintf (name, "%svideo/%s/%s0000.pcx", gamedir, base, base);
- else
- sprintf (name, "%svideo/%s/%s000.pcx", gamedir, base, base);
+ if ( digits == 4 ) {
+ sprintf( name, "%svideo/%s/%s0000.pcx", gamedir, base, base );
+ }
+ else{
+ sprintf( name, "%svideo/%s/%s000.pcx", gamedir, base, base );
+ }
- printf ("%s\n", name);
- Load256Image (name, NULL, &palette, &width, &height);
+ printf( "%s\n", name );
+ Load256Image( name, NULL, &palette, &width, &height );
- output = fopen (savename, "wb");
- if (!output)
- Error ("Can't open %s", savename);
+ output = fopen( savename, "wb" );
+ if ( !output ) {
+ Error( "Can't open %s", savename );
+ }
// write header info
- i = LittleLong (width);
- fwrite (&i, 4, 1, output);
- i = LittleLong (height);
- fwrite (&i, 4, 1, output);
- i = LittleLong (wavinfo.rate);
- fwrite (&i, 4, 1, output);
- i = LittleLong (wavinfo.width);
- fwrite (&i, 4, 1, output);
- i = LittleLong (wavinfo.channels);
- fwrite (&i, 4, 1, output);
+ i = LittleLong( width );
+ fwrite( &i, 4, 1, output );
+ i = LittleLong( height );
+ fwrite( &i, 4, 1, output );
+ i = LittleLong( wavinfo.rate );
+ fwrite( &i, 4, 1, output );
+ i = LittleLong( wavinfo.width );
+ fwrite( &i, 4, 1, output );
+ i = LittleLong( wavinfo.channels );
+ fwrite( &i, 4, 1, output );
// build the dictionary
- for ( frame=startframe ; ; frame++)
+ for ( frame = startframe ; ; frame++ )
{
- printf ("counting ", frame);
- in = LoadFrame (base, frame, digits, &palette);
- if (!in.data)
+ printf( "counting ", frame );
+ in = LoadFrame( base, frame, digits, &palette );
+ if ( !in.data ) {
break;
- Huffman1_Count (in);
- free (in.data);
+ }
+ Huffman1_Count( in );
+ free( in.data );
}
- printf ("\n");
+ printf( "\n" );
// build nodes and write counts
- Huffman1_Build (output);
+ Huffman1_Build( output );
- memset (current_palette, 0, sizeof(current_palette));
+ memset( current_palette, 0, sizeof( current_palette ) );
// compress it with the dictionary
- for (frame=startframe ; ; frame++)
+ for ( frame = startframe ; ; frame++ )
{
- printf ("packing ", frame);
- in = LoadFrame (base, frame, digits, &palette);
- if (!in.data)
+ printf( "packing ", frame );
+ in = LoadFrame( base, frame, digits, &palette );
+ if ( !in.data ) {
break;
+ }
// see if the palette has changed
- for (i=0 ; i<768 ; i++)
- if (palette[i] != current_palette[i])
- {
+ for ( i = 0 ; i < 768 ; i++ )
+ if ( palette[i] != current_palette[i] ) {
// write a palette change
- memcpy (current_palette, palette, sizeof(current_palette));
- command = LittleLong(1);
- fwrite (&command, 1, 4, output);
- fwrite (current_palette, 1, sizeof(current_palette), output);
+ memcpy( current_palette, palette, sizeof( current_palette ) );
+ command = LittleLong( 1 );
+ fwrite( &command, 1, 4, output );
+ fwrite( current_palette, 1, sizeof( current_palette ), output );
break;
}
- if (i == 768)
- {
- command = 0; // no palette change
- fwrite (&command, 1, 4, output);
+ if ( i == 768 ) {
+ command = 0; // no palette change
+ fwrite( &command, 1, 4, output );
}
// save the image
- huffman = Huffman1 (in);
- printf ("%5i bytes after huffman1\n", huffman.count);
+ huffman = Huffman1( in );
+ printf( "%5i bytes after huffman1\n", huffman.count );
- swap = LittleLong (huffman.count);
- fwrite (&swap, 1, sizeof(swap), output);
+ swap = LittleLong( huffman.count );
+ fwrite( &swap, 1, sizeof( swap ), output );
- fwrite (huffman.data, 1, huffman.count, output);
+ fwrite( huffman.data, 1, huffman.count, output );
// save some sound samples
- WriteSound (output, frame);
+ WriteSound( output, frame );
- free (palette);
- free (in.data);
- free (huffman.data);
+ free( palette );
+ free( in.data );
+ free( huffman.data );
}
- printf ("\n");
+ printf( "\n" );
// write end-of-file command
command = 2;
- fwrite (&command, 1, 4, output);
+ fwrite( &command, 1, 4, output );
- printf ("Total size: %i\n", ftell (output));
+ printf( "Total size: %i\n", ftell( output ) );
- fclose (output);
+ fclose( output );
- if (soundtrack)
- free (soundtrack);
+ if ( soundtrack ) {
+ free( soundtrack );
+ }
}
projects / xonotic / netradiant.git / blobdiff