SDL_dataqueue.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
SDL_DataQueue *	SDL_NewDataQueue (const size_t packetlen, const size_t initialslack)
void	SDL_FreeDataQueue (SDL_DataQueue *queue)
void	SDL_ClearDataQueue (SDL_DataQueue *queue, const size_t slack)
int	SDL_WriteToDataQueue (SDL_DataQueue *queue, const void *data, const size_t len)
size_t	SDL_ReadFromDataQueue (SDL_DataQueue *queue, void *buf, const size_t len)
size_t	SDL_PeekIntoDataQueue (SDL_DataQueue *queue, void *buf, const size_t len)
size_t	SDL_CountDataQueue (SDL_DataQueue *queue)
void *	SDL_ReserveSpaceInDataQueue (SDL_DataQueue *queue, const size_t len)

Function Documentation

SDL_ClearDataQueue()

void SDL_ClearDataQueue	(	SDL_DataQueue *	queue,
		const size_t	slack
	)

Definition at line 97 of file SDL_dataqueue.c.

{
    const size_t packet_size = queue ? queue->packet_size : 1;
    const size_t slackpackets = (slack + (packet_size-1)) / packet_size;
    SDL_DataQueuePacket *packet;
    SDL_DataQueuePacket *prev = NULL;
    size_t i;
 
    if (!queue) {
        return;
    }
 
    packet = queue->head;
 
    /* merge the available pool and the current queue into one list. */
    if (packet) {
        queue->tail->next = queue->pool;
    } else {
        packet = queue->pool;
    }
 
    /* Remove the queued packets from the device. */
    queue->tail = NULL;
    queue->head = NULL;
    queue->queued_bytes = 0;
    queue->pool = packet;
 
    /* Optionally keep some slack in the pool to reduce malloc pressure. */
    for (i = 0; packet && (i < slackpackets); i++) {
        prev = packet;
        packet = packet->next;
    }
 
    if (prev) {
        prev->next = NULL;
    } else {
        queue->pool = NULL;
    }
 
    SDL_FreeDataQueueList(packet);  /* free extra packets */
}

References SDL_DataQueue::head, i, SDL_DataQueuePacket::next, NULL, SDL_DataQueue::packet_size, SDL_DataQueue::pool, SDL_DataQueue::queued_bytes, SDL_FreeDataQueueList(), and SDL_DataQueue::tail.

Referenced by SDL_AudioStreamClear(), and SDL_ClearQueuedAudio().

SDL_CountDataQueue()

size_t SDL_CountDataQueue

(

SDL_DataQueue *

queue

)

Definition at line 293 of file SDL_dataqueue.c.

{
    return queue ? queue->queued_bytes : 0;
}

References SDL_DataQueue::queued_bytes.

Referenced by SDL_AudioStreamAvailable(), SDL_BufferQueueDrainCallback(), and SDL_GetQueuedAudioSize().

SDL_FreeDataQueue()

void SDL_FreeDataQueue

(

SDL_DataQueue *

queue

)

Definition at line 87 of file SDL_dataqueue.c.

{
    if (queue) {
        SDL_FreeDataQueueList(queue->head);
        SDL_FreeDataQueueList(queue->pool);
        SDL_free(queue);
    }
}

References SDL_DataQueue::head, SDL_DataQueue::pool, SDL_free, and SDL_FreeDataQueueList().

Referenced by close_audio_device(), and SDL_FreeAudioStream().

SDL_NewDataQueue()

SDL_DataQueue* SDL_NewDataQueue	(	const size_t	packetlen,
		const size_t	initialslack
	)

Definition at line 57 of file SDL_dataqueue.c.

{
    SDL_DataQueue *queue = (SDL_DataQueue *) SDL_malloc(sizeof (SDL_DataQueue));
 
    if (!queue) {
        SDL_OutOfMemory();
        return NULL;
    } else {
        const size_t packetlen = _packetlen ? _packetlen : 1024;
        const size_t wantpackets = (initialslack + (packetlen - 1)) / packetlen;
        size_t i;
 
        SDL_zerop(queue);
        queue->packet_size = packetlen;
 
        for (i = 0; i < wantpackets; i++) {
            SDL_DataQueuePacket *packet = (SDL_DataQueuePacket *) SDL_malloc(sizeof (SDL_DataQueuePacket) + packetlen);
            if (packet) { /* don't care if this fails, we'll deal later. */
                packet->datalen = 0;
                packet->startpos = 0;
                packet->next = queue->pool;
                queue->pool = packet;
            }
        }
    }
 
    return queue;
}

References SDL_DataQueuePacket::datalen, i, SDL_DataQueuePacket::next, NULL, SDL_DataQueue::packet_size, SDL_DataQueue::pool, SDL_malloc, SDL_OutOfMemory, SDL_zerop, and SDL_DataQueuePacket::startpos.

Referenced by open_audio_device(), and SDL_NewAudioStream().

SDL_PeekIntoDataQueue()

size_t SDL_PeekIntoDataQueue	(	SDL_DataQueue *	queue,
		void *	buf,
		const size_t	len
	)

Definition at line 228 of file SDL_dataqueue.c.

{
    size_t len = _len;
    Uint8 *buf = (Uint8 *) _buf;
    Uint8 *ptr = buf;
    SDL_DataQueuePacket *packet;
 
    if (!queue) {
        return 0;
    }
 
    for (packet = queue->head; len && packet; packet = packet->next) {
        const size_t avail = packet->datalen - packet->startpos;
        const size_t cpy = SDL_min(len, avail);
        SDL_assert(queue->queued_bytes >= avail);
 
        SDL_memcpy(ptr, packet->data + packet->startpos, cpy);
        ptr += cpy;
        len -= cpy;
    }
 
    return (size_t) (ptr - buf);
}

References SDL_DataQueuePacket::data, SDL_DataQueuePacket::datalen, SDL_DataQueue::head, SDL_DataQueuePacket::next, ptr, SDL_DataQueue::queued_bytes, SDL_assert, SDL_memcpy, SDL_min, and SDL_DataQueuePacket::startpos.

SDL_ReadFromDataQueue()

size_t SDL_ReadFromDataQueue	(	SDL_DataQueue *	queue,
		void *	buf,
		const size_t	len
	)

Definition at line 253 of file SDL_dataqueue.c.

{
    size_t len = _len;
    Uint8 *buf = (Uint8 *) _buf;
    Uint8 *ptr = buf;
    SDL_DataQueuePacket *packet;
 
    if (!queue) {
        return 0;
    }
 
    while ((len > 0) && ((packet = queue->head) != NULL)) {
        const size_t avail = packet->datalen - packet->startpos;
        const size_t cpy = SDL_min(len, avail);
        SDL_assert(queue->queued_bytes >= avail);
 
        SDL_memcpy(ptr, packet->data + packet->startpos, cpy);
        packet->startpos += cpy;
        ptr += cpy;
        queue->queued_bytes -= cpy;
        len -= cpy;
 
        if (packet->startpos == packet->datalen) {  /* packet is done, put it in the pool. */
            queue->head = packet->next;
            SDL_assert((packet->next != NULL) || (packet == queue->tail));
            packet->next = queue->pool;
            queue->pool = packet;
        }
    }
 
    SDL_assert((queue->head != NULL) == (queue->queued_bytes != 0));
 
    if (queue->head == NULL) {
        queue->tail = NULL;  /* in case we drained the queue entirely. */
    }
 
    return (size_t) (ptr - buf);
}

References SDL_DataQueuePacket::data, SDL_DataQueuePacket::datalen, SDL_DataQueue::head, SDL_DataQueuePacket::next, NULL, SDL_DataQueue::pool, ptr, SDL_DataQueue::queued_bytes, SDL_assert, SDL_memcpy, SDL_min, SDL_DataQueuePacket::startpos, and SDL_DataQueue::tail.

Referenced by SDL_AudioStreamGet(), SDL_BufferQueueDrainCallback(), and SDL_DequeueAudio().

SDL_ReserveSpaceInDataQueue()

void* SDL_ReserveSpaceInDataQueue	(	SDL_DataQueue *	queue,
		const size_t	len
	)

Definition at line 299 of file SDL_dataqueue.c.

{
    SDL_DataQueuePacket *packet;
 
    if (!queue) {
        SDL_InvalidParamError("queue");
        return NULL;
    } else if (len == 0) {
        SDL_InvalidParamError("len");
        return NULL;
    } else if (len > queue->packet_size) {
        SDL_SetError("len is larger than packet size");
        return NULL;
    }
 
    packet = queue->head;
    if (packet) {
        const size_t avail = queue->packet_size - packet->datalen;
        if (len <= avail) {  /* we can use the space at end of this packet. */
            void *retval = packet->data + packet->datalen;
            packet->datalen += len;
            queue->queued_bytes += len;
            return retval;
        }
    }
 
    /* Need a fresh packet. */
    packet = AllocateDataQueuePacket(queue);
    if (!packet) {
        SDL_OutOfMemory();
        return NULL;
    }
 
    packet->datalen = len;
    queue->queued_bytes += len;
    return packet->data;
}

References AllocateDataQueuePacket(), SDL_DataQueuePacket::data, SDL_DataQueuePacket::datalen, SDL_DataQueue::head, NULL, SDL_DataQueue::packet_size, SDL_DataQueue::queued_bytes, retval, SDL_InvalidParamError, SDL_OutOfMemory, and SDL_SetError.

SDL_WriteToDataQueue()

int SDL_WriteToDataQueue	(	SDL_DataQueue *	queue,
		const void *	data,
		const size_t	len
	)

Definition at line 174 of file SDL_dataqueue.c.

{
    size_t len = _len;
    const Uint8 *data = (const Uint8 *) _data;
    const size_t packet_size = queue ? queue->packet_size : 0;
    SDL_DataQueuePacket *orighead;
    SDL_DataQueuePacket *origtail;
    size_t origlen;
    size_t datalen;
 
    if (!queue) {
        return SDL_InvalidParamError("queue");
    }
 
    orighead = queue->head;
    origtail = queue->tail;
    origlen = origtail ? origtail->datalen : 0;
 
    while (len > 0) {
        SDL_DataQueuePacket *packet = queue->tail;
        SDL_assert(!packet || (packet->datalen <= packet_size));
        if (!packet || (packet->datalen >= packet_size)) {
            /* tail packet missing or completely full; we need a new packet. */
            packet = AllocateDataQueuePacket(queue);
            if (!packet) {
                /* uhoh, reset so we've queued nothing new, free what we can. */
                if (!origtail) {
                    packet = queue->head;  /* whole queue. */
                } else {
                    packet = origtail->next;  /* what we added to existing queue. */
                    origtail->next = NULL;
                    origtail->datalen = origlen;
                }
                queue->head = orighead;
                queue->tail = origtail;
                queue->pool = NULL;
 
                SDL_FreeDataQueueList(packet);  /* give back what we can. */
                return SDL_OutOfMemory();
            }
        }
 
        datalen = SDL_min(len, packet_size - packet->datalen);
        SDL_memcpy(packet->data + packet->datalen, data, datalen);
        data += datalen;
        len -= datalen;
        packet->datalen += datalen;
        queue->queued_bytes += datalen;
    }
 
    return 0;
}

References AllocateDataQueuePacket(), SDL_DataQueuePacket::data, SDL_DataQueuePacket::datalen, SDL_DataQueue::head, SDL_DataQueuePacket::next, NULL, SDL_DataQueue::packet_size, SDL_DataQueue::pool, SDL_DataQueue::queued_bytes, SDL_assert, SDL_FreeDataQueueList(), SDL_InvalidParamError, SDL_memcpy, SDL_min, SDL_OutOfMemory, and SDL_DataQueue::tail.

Referenced by SDL_AudioStreamPut(), SDL_AudioStreamPutInternal(), SDL_BufferQueueFillCallback(), and SDL_QueueAudio().