--- /dev/null
+/*
+Copyright (C) 1999-2006 Id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+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 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
+*/
+
+// To do
+
+// Sound error handling (when sound too short)
+// rle b4 huffing
+// adpcm encoding of sound
+
+#if 0
+#include "qdata.h"
+#include "flex.h"
+#include "fc.h"
+#include "adpcm.h"
+
+#define MIN_REPT 15
+#define MAX_REPT 0
+#define HUF_TOKENS (256 + MAX_REPT)
+
+#define BLOCKSIZE 8
+
+#define M_PI 3.14159265358979323846 // matches value in gcc v2 math.h
+#define SQRT2 1.414213562
+
+typedef struct hnode_s
+{
+ int count;
+ qboolean used;
+ int children[2];
+} hnode_t;
+
+typedef struct
+{
+ int rate;
+ int width;
+ int channels;
+ int loopstart;
+ int samples;
+ int dataofs; // chunk starts this many bytes from file start
+} wavinfo_t;
+
+// These weren`t picked out my ass....
+// They were defined at http://www.rahul.net/jfm/dct.html
+// However, I think he plucked them out of his ass.....
+
+float Quantise[BLOCKSIZE * BLOCKSIZE];
+
+float LUT_Quantise[BLOCKSIZE * BLOCKSIZE] =
+{
+ 16.0F/16.0F, 11.0F/16.0F, 10.0F/16.0F, 16.0F/16.0F, 24.0F/16.0F, 40.0F/16.0F, 51.0F/16.0F, 61.0F/16.0F,
+ 12.0F/16.0F, 13.0F/16.0F, 14.0F/16.0F, 19.0F/16.0F, 26.0F/16.0F, 58.0F/16.0F, 60.0F/16.0F, 55.0F/16.0F,
+ 14.0F/16.0F, 13.0F/16.0F, 16.0F/16.0F, 24.0F/16.0F, 40.0F/16.0F, 57.0F/16.0F, 69.0F/16.0F, 56.0F/16.0F,
+ 14.0F/16.0F, 17.0F/16.0F, 22.0F/16.0F, 29.0F/16.0F, 51.0F/16.0F, 87.0F/16.0F, 80.0F/16.0F, 62.0F/16.0F,
+ 18.0F/16.0F, 22.0F/16.0F, 37.0F/16.0F, 56.0F/16.0F, 68.0F/16.0F,109.0F/16.0F,103.0F/16.0F, 77.0F/16.0F,
+ 24.0F/16.0F, 35.0F/16.0F, 55.0F/16.0F, 64.0F/16.0F, 81.0F/16.0F,104.0F/16.0F,113.0F/16.0F, 92.0F/16.0F,
+ 49.0F/16.0F, 64.0F/16.0F, 78.0F/16.0F, 87.0F/16.0F,103.0F/16.0F,121.0F/16.0F,120.0F/16.0F,101.0F/16.0F,
+ 72.0F/16.0F, 92.0F/16.0F, 95.0F/16.0F, 98.0F/16.0F,112.0F/16.0F,100.0F/16.0F,103.0F/16.0F, 99.0F/16.0F
+};
+
+int LUT_ZZ[BLOCKSIZE * BLOCKSIZE] =
+{
+ 0,
+ 1, 8,
+ 16, 9, 2,
+ 3, 10, 17, 24,
+ 32, 25, 18, 11, 4,
+ 5, 12, 19, 26, 33, 40,
+ 48, 41, 34, 27, 20, 13, 6,
+ 7, 14, 21, 28, 35, 42, 49, 56,
+ 57, 50, 43, 36, 29, 22, 15,
+ 23, 30, 37, 44, 51, 58,
+ 59, 52, 45, 38, 31,
+ 39, 46, 53, 60,
+ 61, 54, 47,
+ 55, 62,
+ 63
+};
+
+char base[32];
+
+byte *soundtrack;
+
+byte scaled[256][HUF_TOKENS];
+unsigned int charbits1[256][HUF_TOKENS];
+int charbitscount1[256][HUF_TOKENS];
+hnode_t hnodes1[256][HUF_TOKENS * 2];
+int numhnodes1[256];
+int order0counts[256];
+int numhnodes;
+hnode_t hnodes[512];
+unsigned charbits[256];
+int charbitscount[256];
+
+CineHead_t cinehead;
+
+byte *data_p;
+byte *iff_end;
+byte *last_chunk;
+byte *iff_data;
+int iff_chunk_len;
+
+float dctbase[BLOCKSIZE][BLOCKSIZE];
+float red[BLOCKSIZE * BLOCKSIZE];
+float green[BLOCKSIZE * BLOCKSIZE];
+float blue[BLOCKSIZE * BLOCKSIZE];
+float temp[BLOCKSIZE * BLOCKSIZE];
+
+wavinfo_t wavinfo;
+adpcm_t adpcm;
+
+/*
+===============================================================================
+
+WAV loading
+
+===============================================================================
+*/
+
+/* Intel ADPCM step variation table */
+static int indexTable[16] =
+{
+ -1, -1, -1, -1, 2, 4, 6, 8,
+ -1, -1, -1, -1, 2, 4, 6, 8,
+};
+
+static int stepsizeTable[89] =
+{
+ 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
+ 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
+ 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
+ 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
+ 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
+ 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
+ 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
+ 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+ 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+};
+
+#if 0
+static void adpcm_decoder(char *indata, short *outdata, int len, adpcm_state_t *state)
+{
+ signed char *inp; /* Input buffer pointer */
+ short *outp; /* output buffer pointer */
+ int sign; /* Current adpcm sign bit */
+ int delta; /* Current adpcm output value */
+ int step; /* Stepsize */
+ int valpred; /* Predicted value */
+ int vpdiff; /* Current change to valpred */
+ int index; /* Current step change index */
+ int inputbuffer; /* place to keep next 4-bit value */
+ int bufferstep; /* toggle between inputbuffer/input */
+
+ outp = outdata;
+ inp = (signed char *)indata;
+
+ valpred = state->valprev;
+ index = state->index;
+ step = stepsizeTable[index];
+
+ bufferstep = 0;
+
+ for(; len > 0; len--)
+ {
+ /* Step 1 - get the delta value */
+ if (bufferstep)
+ delta = inputbuffer & 0xf;
+ else
+ {
+ inputbuffer = *inp++;
+ delta = (inputbuffer >> 4) & 0xf;
+ }
+ bufferstep = !bufferstep;
+
+ /* Step 2 - Find new index value (for later) */
+ index += indexTable[delta];
+ if(index < 0)
+ index = 0;
+ if(index > 88)
+ index = 88;
+
+ /* Step 3 - Separate sign and magnitude */
+ sign = delta & 8;
+ delta = delta & 7;
+
+ /* Step 4 - Compute difference and new predicted value */
+ /*
+ ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment
+ ** in adpcm_coder.
+ */
+ vpdiff = step >> 3;
+ if(delta & 4)
+ vpdiff += step;
+ if(delta & 2)
+ vpdiff += step>>1;
+ if(delta & 1)
+ vpdiff += step>>2;
+
+ if (sign)
+ valpred -= vpdiff;
+ else
+ valpred += vpdiff;
+
+ /* Step 5 - clamp output value */
+ if (valpred > 32767)
+ valpred = 32767;
+ else if (valpred < -32768)
+ valpred = -32768;
+
+ /* Step 6 - Update step value */
+ step = stepsizeTable[index];
+
+ /* Step 7 - Output value */
+ *outp++ = valpred;
+ }
+
+ state->valprev = valpred;
+ state->index = index;
+}
+#endif
+
+void adpcm_coder(short *inp, adpcm_t *adpcm)
+{
+ int val; /* Current input sample value */
+ int sign; /* Current adpcm sign bit */
+ int delta; /* Current adpcm output value */
+ int diff; /* Difference between val and valprev */
+ int step; /* Stepsize */
+ int valpred; /* Predicted output value */
+ int vpdiff; /* Current change to valpred */
+ int index; /* Current step change index */
+ int outputbuffer; /* place to keep previous 4-bit value */
+ int bufferstep; /* toggle between outputbuffer/output */
+ adpcm_state_t *state;
+ char *outp;
+ int len;
+
+ state = &adpcm->state;
+ len = state->count;
+ outp = adpcm->adpcm;
+
+ valpred = state->in_valprev;
+ index = state->in_index;
+ step = stepsizeTable[index];
+
+ bufferstep = 1;
+ while(len--)
+ {
+ val = *inp++;
+
+ /* Step 1 - compute difference with previous value */
+ diff = val - valpred;
+ sign = (diff < 0) ? 8 : 0;
+ if (sign)
+ diff = -diff;
+
+ /* Step 2 - Divide and clamp */
+ /* Note:
+ ** This code *approximately* computes:
+ ** delta = diff*4/step;
+ ** vpdiff = (delta+0.5)*step/4;
+ ** but in shift step bits are dropped. The net result of this is
+ ** that even if you have fast mul/div hardware you cannot put it to
+ ** good use since the fixup would be too expensive.
+ */
+ delta = 0;
+ vpdiff = (step >> 3);
+
+ if (diff >= step)
+ {
+ delta = 4;
+ diff -= step;
+ vpdiff += step;
+ }
+ step >>= 1;
+ if (diff >= step)
+ {
+ delta |= 2;
+ diff -= step;
+ vpdiff += step;
+ }
+ step >>= 1;
+ if (diff >= step)
+ {
+ delta |= 1;
+ vpdiff += step;
+ }
+
+ /* Step 3 - Update previous value */
+ if (sign)
+ valpred -= vpdiff;
+ else
+ valpred += vpdiff;
+
+ /* Step 4 - Clamp previous value to 16 bits */
+ if (valpred > 32767)
+ valpred = 32767;
+ else if (valpred < -32768)
+ valpred = -32768;
+
+ /* Step 5 - Assemble value, update index and step values */
+ delta |= sign;
+
+ index += indexTable[delta];
+ if (index < 0)
+ index = 0;
+ if (index > 88)
+ index = 88;
+ step = stepsizeTable[index];
+
+ /* Step 6 - Output value */
+ if (bufferstep)
+ outputbuffer = (delta << 4) & 0xf0;
+ else
+ *outp++ = (delta & 0x0f) | outputbuffer;
+
+ bufferstep = !bufferstep;
+ }
+
+ /* Output last step, if needed */
+ if(!bufferstep)
+ *outp++ = outputbuffer;
+
+ state->out_valprev = valpred;
+ state->out_index = index;
+}
+
+void FindNextChunk(char *name)
+{
+ while(1)
+ {
+ data_p = last_chunk;
+
+ if(data_p >= iff_end)
+ { // didn't find the chunk
+ data_p = NULL;
+ return;
+ }
+
+ data_p += 4;
+ iff_chunk_len = *(long *)data_p;
+ data_p += 4;
+ if(iff_chunk_len < 0)
+ {
+ data_p = NULL;
+ return;
+ }
+
+ data_p -= 8;
+ last_chunk = data_p + 8 + ((iff_chunk_len + 1) & ~1);
+ if (!strncmp(data_p, name, 4))
+ return;
+ }
+}
+
+void FindChunk(char *name)
+{
+ last_chunk = iff_data;
+ FindNextChunk (name);
+}
+
+void DumpChunks(void)
+{
+ char str[5];
+
+ str[4] = 0;
+ data_p = iff_data;
+ do
+ {
+ memcpy (str, data_p, 4);
+ data_p += 4;
+ iff_chunk_len = *(long *)data_p;
+ data_p += 4;
+ 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)
+ 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");
+ return(info);
+ }
+
+// get "fmt " chunk
+ iff_data = data_p + 12;
+
+ FindChunk("fmt ");
+ if(!data_p)
+ {
+ printf("Missing fmt chunk\n");
+ return(info);
+ }
+ data_p += 8;
+ format = *(short *)data_p;
+ data_p += 2;
+ if (format != 1)
+ {
+ printf("Microsoft PCM format only\n");
+ return(info);
+ }
+
+ info.channels = *(short *)data_p;
+ data_p += 2;
+ info.rate = *(long *)data_p;
+ data_p += 4;
+ data_p += 6;
+ info.width = *(short *)data_p / 8;
+ data_p += 2;
+
+// get cue chunk
+ FindChunk("cue ");
+ if(data_p)
+ {
+ data_p += 32;
+ info.loopstart = *(long *)data_p;
+ data_p += 4;
+
+// if the next chunk is a LIST chunk, look for a cue length marker
+ FindNextChunk ("LIST");
+ if(data_p)
+ {
+// this is not a proper parse, but it works with cooledit...
+ if (!strncmp (data_p + 28, "mark", 4))
+ {
+ data_p += 24;
+ i = *(long *)data_p; // samples in loop
+ data_p += 4;
+ info.samples = info.loopstart + i;
+ }
+ }
+ }
+ else
+ info.loopstart = -1;
+
+// find data chunk
+ FindChunk("data");
+ if (!data_p)
+ {
+ printf("Missing data chunk\n");
+ return(info);
+ }
+
+ data_p += 4;
+ samples = *(long *)data_p;
+ data_p += 4;
+
+ if (info.samples)
+ {
+ if(samples < info.samples)
+ Error ("Sound %s has a bad loop length", name);
+ }
+ else
+ info.samples = samples;
+
+ info.dataofs = data_p - wav;
+ return(info);
+}
+
+// ==============
+// LoadSoundtrack
+// ==============
+
+void LoadSoundtrack()
+{
+ char name[1024];
+ FILE *f;
+ int len;
+
+ soundtrack = NULL;
+ sprintf (name, "%svideo/%s/%s.wav", gamedir, base, base);
+ printf ("\nLoading sound : %s\n", name);
+ f = fopen (name, "rb");
+ if (!f)
+ {
+ printf ("\nNo soundtrack for %s\n", base);
+ return;
+ }
+ len = Q_filelength(f);
+ soundtrack = SafeMalloc(len, "LoadSoundtrack");
+ fread(soundtrack, 1, len, f);
+ fclose(f);
+
+ wavinfo = GetWavinfo(name, soundtrack, len);
+ adpcm.state.out_valprev = 0;
+ adpcm.state.out_index = 0;
+}
+
+// ==================
+// WriteSound
+// ==================
+
+int WriteSound(FILE *output, int frame, int numframes)
+{
+ int start, end;
+ int count;
+ int empty = 0;
+ int width;
+ char *work;
+
+ width = wavinfo.width * wavinfo.channels;
+ start = ((frame * wavinfo.rate / 14) + 31) & 0xffffffe0; // start sample
+ end = (((frame + numframes) * wavinfo.rate / 14) + 31) & 0xffffffe0; // end sample
+ count = end - start;
+
+ work = soundtrack + wavinfo.dataofs + (start * width);
+ adpcm.state.count = count * wavinfo.channels; // Number of samples
+ adpcm.state.in_valprev = adpcm.state.out_valprev;
+ adpcm.state.in_index = adpcm.state.out_index;
+ adpcm_coder((short *)work, &adpcm);
+ WriteHeader(output, FC_SOUND_22KMADPCM, FC_ADPCM_VERSION, (adpcm.state.count / 2) + sizeof(adpcm_state_t), (char *)&adpcm);
+ return(count / 2);
+}
+// ==============================
+// Basic run length encoder
+// ==============================
+
+char *RLEZZ(char *in, char *out)
+{
+ int srun;
+ char count;
+ int idx = 0;
+
+ while(idx < 64)
+ {
+ srun = idx; // Start of run
+
+ while(idx < 63)
+ {
+ if(in[LUT_ZZ[idx]] != in[LUT_ZZ[idx + 1]])
+ break;
+ idx++;
+ }
+ count = (char)(idx - srun); // count of repeated bytes
+
+ if(!count)
+ {
+ while(idx < 63)
+ {
+ if(in[LUT_ZZ[idx]] == in[LUT_ZZ[idx + 1]])
+ break;
+ idx++;
+ }
+ if(idx == 63)
+ idx++;
+
+ count = (char)(idx - srun); // count of unique bytes
+ *out++ = count;
+ while(count--)
+ *out++ = in[LUT_ZZ[srun++]];
+ }
+ else
+ {
+ *out++ = -(count + 1);
+ *out++ = in[LUT_ZZ[idx]];
+ idx++;
+ }
+ }
+ return(out);
+}
+
+// ==============================
+// Discrete Cosine Transformation
+// ==============================
+
+void init_base(float quant)
+{
+ int y, x;
+
+ for(y = 0; y < BLOCKSIZE; y++)
+ for(x = 0; x < BLOCKSIZE; x++)
+ {
+ if(y == 0)
+ dctbase[y][x] = 1;
+ else
+ dctbase[y][x] = SQRT2 * cos(((x * 2 + 1) * y * M_PI) / (BLOCKSIZE * 2));
+ }
+
+ for(y = 0; y < BLOCKSIZE * BLOCKSIZE; y++)
+ Quantise[y] = LUT_Quantise[y] / quant;
+}
+
+void SplitComponents(byte *src, int width, int height)
+{
+ int i, j;
+ float *tr = red;
+ float *tg = green;
+ float *tb = blue;
+
+ for(i = 0; i < BLOCKSIZE; i++, src += (width - BLOCKSIZE) * 4)
+ for(j = 0; j < BLOCKSIZE; j++)
+ {
+ *tr++ = ((float)*src++) - 128.0F;
+ *tg++ = ((float)*src++) - 128.0F;
+ *tb++ = ((float)*src++) - 128.0F;
+ src++;
+ }
+}
+
+void transferH(float *src, float *dst)
+{
+ int y, dx, dy;
+ float sum;
+ float *work;
+
+ for(y = 0; y < BLOCKSIZE; y++, src += BLOCKSIZE)
+ {
+ for(dy = 0; dy < BLOCKSIZE; dy++)
+ {
+ sum = 0;
+ work = src;
+ for(dx = 0; dx < BLOCKSIZE; dx++, work++)
+ sum += dctbase[dy][dx] * *work;
+
+ *dst++ = sum / BLOCKSIZE;
+ }
+ }
+}
+
+void transferV(float *src, float *dst)
+{
+ int x, dy, fy;
+ float sum;
+ float *work;
+
+ for(x = 0; x < BLOCKSIZE; x++, src++, dst++)
+ {
+ for(fy = 0; fy < BLOCKSIZE; fy++)
+ {
+ sum = 0;
+ work = src;
+ for(dy = 0; dy < BLOCKSIZE; dy++, work += BLOCKSIZE)
+ sum += dctbase[fy][dy] * *work;
+
+ dst[fy * BLOCKSIZE] = sum / BLOCKSIZE;
+ }
+ }
+}
+
+char *Combine(byte *dst, float *p, float *q)
+{
+ int i, j;
+ byte rlesrc[BLOCKSIZE * BLOCKSIZE];
+ int c;
+ byte *work;
+
+ work = rlesrc;
+ for(j = 0; j < BLOCKSIZE; j++)
+ for(i = 0; i < BLOCKSIZE; i++)
+ {
+ c = (int)((*p++ / *q++) + 128.5F);
+ c -= 128;
+
+ if(c < -128)
+ c = -128;
+ if(c > 127)
+ c = 127;
+
+ *work++ = (char)c;
+ }
+
+ dst = RLEZZ(rlesrc, dst);
+ return(dst);
+}
+
+char *CombineComponents(char *dst, int width, int height)
+{
+ dst = Combine(dst, red, Quantise);
+ dst = Combine(dst, green, Quantise);
+ dst = Combine(dst, blue, Quantise);
+ return(dst);
+}
+
+void DCT(cblock_t *out, cblock_t in, int width, int height)
+{
+ int x, y;
+ char *cursrc;
+ char *curdst;
+
+ curdst = out->data;
+ for(y = 0; y < height; y += BLOCKSIZE)
+ for(x = 0; x < width; x += BLOCKSIZE)
+ {
+ cursrc = in.data + ((y * width) + x) * 4;
+ SplitComponents(cursrc, width, height);
+ transferH(red, temp);
+ transferV(temp, red);
+ transferH(green, temp);
+ transferV(temp, green);
+ transferH(blue, temp);
+ transferV(temp, blue);
+ curdst = CombineComponents(curdst, width, height);
+ }
+ out->count = curdst - out->data;
+}
+
+// ==================
+// 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);
+ bits |= 1;
+ BuildChars1(prev, node->children[1], bits, bitcount+1);
+}
+
+// ==================
+// SmallestNode1
+// ==================
+
+int SmallestNode1(hnode_t *hnodes, int numhnodes)
+{
+ int i;
+ int best, bestnode;
+
+ best = 99999999;
+ bestnode = -1;
+ for(i = 0; i < numhnodes; i++)
+ {
+ if(hnodes[i].used)
+ continue;
+ if(!hnodes[i].count)
+ continue;
+ if(hnodes[i].count < best)
+ {
+ best = hnodes[i].count;
+ bestnode = i;
+ }
+ }
+
+ if (bestnode == -1)
+ return(-1);
+
+ hnodes[bestnode].used = true;
+ return(bestnode);
+}
+
+// ==================
+// BuildTree1
+// ==================
+
+void BuildTree1(int prev)
+{
+ hnode_t *node, *nodebase;
+ int numhnodes;
+
+ // build the nodes
+ numhnodes = HUF_TOKENS;
+ nodebase = hnodes1[prev];
+ 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[1] = SmallestNode1 (nodebase, numhnodes);
+ if (node->children[1] == -1)
+ break;
+
+ node->count = nodebase[node->children[0]].count +
+ nodebase[node->children[1]].count;
+ numhnodes++;
+ }
+ 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;
+
+ prev = 0;
+ for(i = 0; i < in.count; i++)
+ {
+ v = in.data[i];
+ order0counts[v]++;
+ hnodes1[prev][v].count++;
+ prev = 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;
+ }
+ }
+}
+
+// ==================
+// Huffman1_Build
+// ==================
+
+void Huffman1_Build()
+{
+ 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++)
+ {
+ if (hnodes1[i][j].count > max)
+ max = hnodes1[i][j].count;
+ }
+ if (max == 0)
+ max = 1;
+ total = 0;
+// easy to overflow 32 bits here!
+ for(j = 0; j < HUF_TOKENS; j++)
+ {
+ 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)
+ total++;
+ }
+ if (total == 1)
+ { // must have two tokens
+ if (!scaled[i][0])
+ scaled[i][0] = hnodes1[i][0].count = 1;
+ else
+ scaled[i][1] = hnodes1[i][1].count = 1;
+ }
+ BuildTree1 (i);
+ }
+}
+
+// ==================
+// 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 = SafeMalloc((in.count * 2) + 1024 + 4, "Huffman");
+ memset(out_p, 0, (in.count * 2) + 1024 + 4);
+
+ // leave space for compressed count
+ out_p += 4;
+ // write count
+ *(long *)out_p = in.count;
+ out_p += 4;
+
+ // write bits
+ outbits = 0;
+ prev = 0;
+ 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)
+ {
+ c--;
+ if (bits & (1 << c))
+ out_p[outbits>>3] |= 1 << (outbits & 7);
+ outbits++;
+ }
+
+ prev = v;
+ // check for repeat encodes
+ 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)
+ {
+ c--;
+ if(bits & (1 << c))
+ out_p[outbits >> 3] |= 1 << (outbits & 7);
+ outbits++;
+ }
+ i += rept - 1;
+ }
+ }
+ out_p += (outbits + 7) >> 3;
+ out.count = out_p - out.data;
+
+ out_p = out.data;
+ *(long *)out_p = out.count;
+ return(out);
+}
+// ===================
+// LoadFrame
+// ===================
+
+void LoadFrame(cblock_t *out, char *base, int frame)
+{
+ cblock_t in;
+ int width, height;
+ char name[1024];
+ FILE *f;
+
+ in.data = NULL;
+ in.count = -1;
+ sprintf (name, "%svideo/%s/%s%04i.tga", gamedir, base, base, frame);
+
+ f = fopen(name, "rb");
+ if (!f)
+ {
+ out->data = NULL;
+ return;
+ }
+ fclose (f);
+
+ LoadTGA(name, &in.data, &width, &height);
+ if((width != cinehead.Width) || (height != cinehead.Height))
+ {
+ free(in.data);
+ printf("Invalid picture size\n");
+ out->data = NULL;
+ return;
+ }
+ out->data = SafeMalloc(width * height * 3, "LoadFrame"); // rle could possibly expand file so this not 100% safe (however DCT should force a lot of compression)
+ DCT(out, in, width, height);
+ free(in.data);
+}
+
+// ==================================
+// Cmd_Video
+//
+// video <directory> <framedigits>
+// ==================================
+
+void Cmd_Video()
+{
+ char savename[256];
+ char name[256];
+ FILE *output;
+ int frame;
+ int width, height;
+ cblock_t in, huffman;
+ int size;
+ float dctconst;
+ int maxsize, ssize;
+ int min_rle_size, warnings;
+ int ave_image, ave_sound;
+
+ GetScriptToken(false);
+ strcpy(base, token);
+ if (g_release)
+ return;
+
+ GetScriptToken(false);
+ dctconst = atof(token);
+ GetScriptToken(false);
+ maxsize = atoi(token);
+
+ 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));
+
+ // load the entire sound wav file if present
+ LoadSoundtrack();
+
+ cinehead.SndRate = wavinfo.rate;
+ cinehead.SndWidth = wavinfo.width;
+ cinehead.SndChannels = wavinfo.channels;
+
+ sprintf(name, "%svideo/%s/%s0000.tga", gamedir, base, base);
+ printf("Loading sequence : %s\n", name);
+ printf("DCT constant : %f\n", dctconst);
+
+ LoadTGA (name, NULL, &width, &height);
+
+ output = fopen (savename, "wb");
+ if (!output)
+ Error ("Can't open %s", savename);
+
+ if((width % BLOCKSIZE) || (height % BLOCKSIZE))
+ Error("Width and height must be a multiple of %d", BLOCKSIZE);
+
+ cinehead.Width = width;
+ cinehead.Height = height;
+ init_base(dctconst);
+
+ // build the dictionary
+ printf("Counting : ");
+ min_rle_size = 0;
+ for (frame = 0; ; frame++)
+ {
+ printf(".");
+ LoadFrame(&in, base, frame);
+ if(!in.data)
+ break;
+ Huffman1_Count(in);
+ if(in.count > min_rle_size)
+ min_rle_size = in.count;
+ free(in.data);
+ }
+ printf ("\n");
+ cinehead.NumFrames = frame;
+ printf("Num Frames : %d\n", frame);
+ cinehead.MaxRleSize = (min_rle_size + 0x1f) & 0xfffffe0;
+ cinehead.MaxSndSize = ((4 * wavinfo.rate * wavinfo.channels / 14) + 0x1f) & 0xffffffe0;
+
+ WriteHeader(output, FC_HEADER_NAME, FC_HEADER_VERSION, sizeof(CineHead_t), &cinehead);
+
+ // build nodes and write counts
+ Huffman1_Build();
+ WriteHeader(output, FC_HUFFBITS_NAME, FC_HUFFBITS_VERSION, sizeof(scaled), scaled);
+ WriteHeader(output, FC_QUANT_NAME, FC_QUANT_VERSION, sizeof(Quantise), Quantise);
+
+ ave_image = 0;
+ ave_sound = 0;
+ warnings = 0;
+ // compress it with the dictionary
+ if(soundtrack)
+ {
+ ssize = WriteSound(output, frame, 4);
+ ave_sound += ssize;
+ }
+
+ for (frame = 0; frame < cinehead.NumFrames; frame++)
+ {
+ // save some sound samples
+ printf ("Packing : ", frame);
+ LoadFrame(&in, base, frame);
+
+ // save the image
+ huffman = Huffman1(in);
+ printf ("%d bytes rle, %d bytes huffman", in.count, huffman.count);
+ size = (huffman.count + 3) & 0xfffffffc; // round up to longwords
+ if(size > maxsize)
+ {
+ printf(" ** WARNING **");
+ warnings++;
+ }
+ printf("\n");
+ ave_image += huffman.count;
+
+ WriteHeader(output, FC_IMAGE_NAME, FC_IMAGE_VERSION, size, huffman.data);
+ if(soundtrack)
+ {
+ ssize = WriteSound(output, frame + 4, 1);
+ ave_sound += ssize;
+ }
+
+ free (in.data);
+ free (huffman.data);
+ }
+ printf("\nTotal size: %d (headers + %d image + %d sound)\n", ftell(output), ave_image, ave_sound);
+ printf("Data rate : %d bytes per sec (image and sound)\n", (ave_image + ave_sound) / cinehead.NumFrames);
+ printf("Cin created ok with %d warnings.\n", warnings);
+ fclose (output);
+
+ if (soundtrack)
+ free (soundtrack);
+}
+#endif
+
+void Cmd_Video()
+{
+}
+
+// end
+
projects / voretournament / voretournament.git / blobdiff