fifo.c File Reference

#include "shared/shared.h"
#include "common/fifo.h"
#include "common/msg.h"

Go to the source code of this file.

Functions
size_t	FIFO_Read (fifo_t *fifo, void *buffer, size_t len)
size_t	FIFO_Write (fifo_t *fifo, const void *buffer, size_t len)
qboolean	FIFO_ReadMessage (fifo_t *fifo, size_t msglen)

Function Documentation

FIFO_Read()

size_t FIFO_Read	(	fifo_t *	fifo,
		void *	buffer,
		size_t	len
	)

Definition at line 23 of file fifo.c.

{
    size_t wrapped, head = fifo->ay - fifo->ax;
 
    if (head > len) {
        if (buffer) {
            memcpy(buffer, fifo->data + fifo->ax, len);
            fifo->ax += len;
        }
        return len;
    }
 
    wrapped = len - head;
    if (wrapped > fifo->bs) {
        wrapped = fifo->bs;
    }
    if (buffer) {
        memcpy(buffer, fifo->data + fifo->ax, head);
        memcpy((byte *)buffer + head, fifo->data, wrapped);
        fifo->ax = wrapped;
        fifo->ay = fifo->bs;
        fifo->bs = 0;
    }
 
    return head + wrapped;
}

Referenced by gtv_read_frame().

FIFO_ReadMessage()

qboolean FIFO_ReadMessage	(	fifo_t *	fifo,
		size_t	msglen
	)

Definition at line 89 of file fifo.c.

{
    size_t len;
    byte *data;
 
    data = FIFO_Peek(fifo, &len);
    if (len < msglen) {
        // read in two chunks into message buffer
        if (!FIFO_TryRead(fifo, msg_read_buffer, msglen)) {
            return qfalse; // not yet available
        }
        SZ_Init(&msg_read, msg_read_buffer, sizeof(msg_read_buffer));
    } else {
        // read in a single block without copying any memory
        SZ_Init(&msg_read, data, msglen);
        FIFO_Decommit(fifo, msglen);
    }
 
    msg_read.cursize = msglen;
    return qtrue;
}

Referenced by AC_ParseMessage(), gtv_read_frame(), and parse_message().

FIFO_Write()

size_t FIFO_Write	(	fifo_t *	fifo,
		const void *	buffer,
		size_t	len
	)

Definition at line 50 of file fifo.c.

{
    size_t tail, wrapped, remaining;
 
    if (fifo->bs) {
        remaining = fifo->ax - fifo->bs;
        if (len > remaining) {
            len = remaining;
        }
        if (buffer) {
            memcpy(fifo->data + fifo->bs, buffer, len);
            fifo->bs += len;
        }
        return len;
    }
 
    tail = fifo->size - fifo->ay;
    if (tail > len) {
        if (buffer) {
            memcpy(fifo->data + fifo->ay, buffer, len);
            fifo->ay += len;
        }
        return len;
    }
 
    wrapped = len - tail;
    if (wrapped > fifo->ax) {
        wrapped = fifo->ax;
    }
    if (buffer) {
        memcpy(fifo->data + fifo->ay, buffer, tail);
        memcpy(fifo->data, (byte *)buffer + tail, wrapped);
        fifo->ay = fifo->size;
        fifo->bs = wrapped;
    }
 
    return tail + wrapped;
}

Referenced by AC_Flush(), parse_stream_data(), and write_stream().