/**
* Write the header
* @param[in] hWave The handle of wave
* @retval SUCCESS If succeeded
* @retval FAILURE If failed
*/
static BRESULT WriteHeader(WAVEFILEH hWave)
{
struct TagRiffChunk riff;
struct tagChunk chunk;
struct TagWaveFormat format;
UINT nFileSize;
UINT nBlockAlign;
UINT nAvgBytesPerSec;
nFileSize = hWave->nDataSize;
nFileSize += 4 + sizeof(chunk) + sizeof(format) + sizeof(chunk);
riff.riff = MAKEID('R', 'I', 'F', 'F');
STOREINTELDWORD(riff.fileSize, nFileSize);
riff.fileType = MAKEID('W', 'A', 'V', 'E');
if (file_write(hWave->fh, &riff, sizeof(riff)) != sizeof(riff))
{
return FAILURE;
}
chunk.id = MAKEID('f', 'm', 't', ' ');
STOREINTELDWORD(chunk.size, sizeof(format));
if (file_write(hWave->fh, &chunk, sizeof(chunk)) != sizeof(chunk))
{
return FAILURE;
}
nBlockAlign = hWave->nChannels * (hWave->nBits / 8);
nAvgBytesPerSec = nBlockAlign * hWave->nRate;
STOREINTELWORD(format.formatTag, WAVE_FORMAT_PCM);
STOREINTELWORD(format.channels, hWave->nChannels);
STOREINTELDWORD(format.samplePerSec, hWave->nRate);
STOREINTELDWORD(format.avgBytesPerSec, nAvgBytesPerSec);
STOREINTELWORD(format.blockAlign, nBlockAlign);
STOREINTELWORD(format.bitsPerSample, hWave->nBits);
if (file_write(hWave->fh, &format, sizeof(format)) != sizeof(format))
{
return FAILURE;
}
chunk.id = MAKEID('d', 'a', 't', 'a');
STOREINTELDWORD(chunk.size, hWave->nDataSize);
if (file_write(hWave->fh, &chunk, sizeof(chunk)) != sizeof(chunk))
{
return FAILURE;
}
return SUCCESS;
}
void NetChannel::CopyNormalFragments()
{
fragbuf_t *p, *n;
int totalSize;
if (!m_incomingbufs[FRAG_NORMAL_STREAM]) {
m_System->DPrintf("WARNING! NetChannel::CopyNormalFragments: called with no fragments readied.\n");
return;
}
totalSize = 0;
p = m_incomingbufs[FRAG_NORMAL_STREAM];
while (p)
{
totalSize += p->size;
p = p->next;
}
NetPacket *packet = new NetPacket;
packet->seqnr = m_incoming_sequence;
packet->connectionless = false;
packet->time = m_System->GetTime();
packet->address.FromNetAddress(&m_remote_address);
packet->data.Resize(totalSize);
p = m_incomingbufs[FRAG_NORMAL_STREAM];
while (p)
{
n = p->next;
packet->data.WriteBuf(p->data, p->size);
Mem_Free(p);
p = n;
}
if (*(uint32 *)packet->data.GetData() == MAKEID('B', 'Z', '2', '\0'))
{
char uncompressed[65536];
unsigned int uncompressedSize = 65536;
BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char *)packet->data.GetData() + 4, totalSize - 4, 1, 0);
packet->data.Resize(uncompressedSize);
packet->data.WriteBuf(uncompressed, uncompressedSize);
}
packet->data.Reset();
m_incomingPackets.AddHead(packet);
m_incomingbufs[FRAG_NORMAL_STREAM] = nullptr;
}
int Disp_GridIndex( CCoreDispInfo *pDispInfo )
{
// quick hash the center into the grid and put the whole terrain in that grid
Vector mins, maxs;
pDispInfo->GetNode(0)->GetBoundingBox( mins, maxs );
Vector center;
center = 0.5 * (mins + maxs);
// make sure it's positive
center += Vector(MAX_COORD_INTEGER,MAX_COORD_INTEGER,MAX_COORD_INTEGER);
int gridX = center.x / DISP_GRID_SIZEX;
int gridY = center.y / DISP_GRID_SIZEY;
int gridZ = center.z / DISP_GRID_SIZEZ;
gridX &= 0xFF;
gridY &= 0xFF;
gridZ &= 0xFF;
return MAKEID( gridX, gridY, gridZ, 0 );
}
/* <66786> ../engine/net_chan.c:1723 */
qboolean Netchan_CopyNormalFragments(netchan_t *chan)
{
fragbuf_t *p, *n;
if (!chan->incomingready[FRAG_NORMAL_STREAM])
return FALSE;
if (!chan->incomingbufs[FRAG_NORMAL_STREAM])
{
Con_Printf("Netchan_CopyNormalFragments: Called with no fragments readied\n");
chan->incomingready[FRAG_NORMAL_STREAM] = FALSE;
return FALSE;
}
p = chan->incomingbufs[FRAG_NORMAL_STREAM];
SZ_Clear(&net_message);
MSG_BeginReading();
while (p)
{
n = p->next;
SZ_Write(&net_message, p->frag_message.data, p->frag_message.cursize);
Mem_Free(p);
p = n;
}
if (*(uint32 *)net_message.data == MAKEID('B', 'Z', '2', '\0'))
{
char uncompressed[65536];
unsigned int uncompressedSize = 65536;
BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char*)net_message.data + 4, net_message.cursize - 4, 1, 0);
Q_memcpy(net_message.data, uncompressed, uncompressedSize);
net_message.cursize = uncompressedSize;
}
chan->incomingbufs[FRAG_NORMAL_STREAM] = NULL;
chan->incomingready[FRAG_NORMAL_STREAM] = false;
return TRUE;
}
}
#define writevar(var,sz) \
if(memfile_write(&var,1,sz,file) != sz) { \
log_printf("state_save: error writing " #var "\n"); \
return(1); \
}
typedef struct blockfunc_s {
u32 type;
u32 size;
void (*func)(int,u8*);
} blockfunc_t;
static blockfunc_t blockinfo[16];
static u32 ident = MAKEID('N','S','T','\0');
static u32 version = 0x0100;
int state_init()
{
memset(blockinfo,0,sizeof(blockfunc_t) * 16);
return(0);
}
void state_kill()
{
}
void state_register(u32 type,void (*func)(int,u8*))
{
int i;
qboolean Netchan_CopyNormalFragments(netchan_t *chan)
{
fragbuf_t *p, *n;
if (!chan->incomingready[FRAG_NORMAL_STREAM])
return FALSE;
if (!chan->incomingbufs[FRAG_NORMAL_STREAM])
{
Con_Printf("%s: Called with no fragments readied\n", __func__);
chan->incomingready[FRAG_NORMAL_STREAM] = FALSE;
return FALSE;
}
p = chan->incomingbufs[FRAG_NORMAL_STREAM];
SZ_Clear(&net_message);
MSG_BeginReading();
#ifdef REHLDS_FIXES
bool overflowed = false;
#endif // REHLDS_FIXES
while (p)
{
n = p->next;
#ifdef REHLDS_FIXES
if (net_message.cursize + p->frag_message.cursize <= net_message.maxsize)
SZ_Write(&net_message, p->frag_message.data, p->frag_message.cursize);
else
overflowed = true;
#else // REHLDS_FIXES
SZ_Write(&net_message, p->frag_message.data, p->frag_message.cursize);
#endif // REHLDS_FIXES
Mem_Free(p);
p = n;
}
#ifdef REHLDS_FIXES
if (overflowed)
{
if (chan->player_slot == 0)
{
Con_Printf("%s: Incoming overflowed\n", __func__);
}
else
{
Con_Printf("%s: Incoming overflowed from %s\n", __func__, g_psvs.clients[chan->player_slot - 1].name);
}
SZ_Clear(&net_message);
chan->incomingbufs[FRAG_NORMAL_STREAM] = nullptr;
chan->incomingready[FRAG_NORMAL_STREAM] = FALSE;
return FALSE;
}
#endif // REHLDS_FIXES
if (*(uint32 *)net_message.data == MAKEID('B', 'Z', '2', '\0'))
{
char uncompressed[65536];
unsigned int uncompressedSize = 65536;
BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char*)net_message.data + 4, net_message.cursize - 4, 1, 0);
Q_memcpy(net_message.data, uncompressed, uncompressedSize);
net_message.cursize = uncompressedSize;
}
chan->incomingbufs[FRAG_NORMAL_STREAM] = nullptr;
chan->incomingready[FRAG_NORMAL_STREAM] = FALSE;
return TRUE;
}
void Netchan_CreateFragments_(qboolean server, netchan_t *chan, sizebuf_t *msg)
{
fragbuf_t *buf;
int chunksize;
int send;
int remaining;
int pos;
int bufferid = 1;
fragbufwaiting_t *wait, *p;
if (msg->cursize == 0)
{
return;
}
// Compress if not done already
if (*(uint32 *)msg->data != MAKEID('B', 'Z', '2', '\0'))
{
unsigned char compressed[65536];
char hdr[4] = "BZ2";
unsigned int compressedSize = msg->cursize - sizeof(hdr); // we should fit in same data buffer minus 4 bytes for a header
if (!BZ2_bzBuffToBuffCompress((char *)compressed, &compressedSize, (char *)msg->data, msg->cursize, 9, 0, 30))
{
Con_DPrintf("Compressing split packet (%d -> %d bytes)\n", msg->cursize, compressedSize);
Q_memcpy(msg->data, hdr, sizeof(hdr));
Q_memcpy(msg->data + sizeof(hdr), compressed, compressedSize);
msg->cursize = compressedSize + sizeof(hdr);
}
}
chunksize = chan->pfnNetchan_Blocksize(chan->connection_status);
wait = (fragbufwaiting_t *)Mem_ZeroMalloc(sizeof(fragbufwaiting_t));
remaining = msg->cursize;
pos = 0;
while (remaining > 0)
{
send = min(remaining, chunksize);
remaining -= send;
buf = Netchan_AllocFragbuf();
if (!buf)
{
return;
}
buf->bufferid = bufferid++;
// Copy in data
SZ_Clear(&buf->frag_message);
SZ_Write(&buf->frag_message, &msg->data[pos], send);
pos += send;
Netchan_AddFragbufToTail(wait, buf);
}
// Now add waiting list item to the end of buffer queue
if (!chan->waitlist[FRAG_NORMAL_STREAM])
{
chan->waitlist[FRAG_NORMAL_STREAM] = wait;
}
else
{
p = chan->waitlist[FRAG_NORMAL_STREAM];
while (p->next)
{
p = p->next;
}
p->next = wait;
}
}
