[deb_shairplay.git] / src / lib / raop_buffer.c

/**
 *  Copyright (C) 2011-2012  Juho Vähä-Herttua
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 */

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>

#include "raop_buffer.h"
#include "raop_rtp.h"
#include "utils.h"

#include <stdint.h>
#include "crypto/crypto.h"
#include "alac/alac.h"

#define RAOP_BUFFER_LENGTH 16

typedef struct {
	/* Packet available */
	int available;

	/* RTP header */
	unsigned char flags;
	unsigned char type;
	unsigned short seqnum;
	unsigned int timestamp;
	unsigned int ssrc;

	/* Audio buffer of valid length */
	int audio_buffer_size;
	int audio_buffer_len;
	void *audio_buffer;
} raop_buffer_entry_t;

struct raop_buffer_s {
	/* AES key and IV */
	unsigned char aeskey[RAOP_AESKEY_LEN];
	unsigned char aesiv[RAOP_AESIV_LEN];

	/* ALAC decoder */
	ALACSpecificConfig alacConfig;
	alac_file *alac;

	/* First and last seqnum */
	int is_empty;
	unsigned short first_seqnum;
	unsigned short last_seqnum;

	/* RTP buffer entries */
	raop_buffer_entry_t entries[RAOP_BUFFER_LENGTH];

	/* Buffer of all audio buffers */
	int buffer_size;
	void *buffer;
};


static int
get_fmtp_info(ALACSpecificConfig *config, const char *fmtp)
{
	int intarr[12];
	char *original;
	char *strptr;
	int i;

	/* Parse fmtp string to integers */
	original = strptr = strdup(fmtp);
	for (i=0; i<12; i++) {
		if (strptr == NULL) {
			free(original);
			return -1;
		}
		intarr[i] = atoi(utils_strsep(&strptr, " "));
	}
	free(original);
	original = strptr = NULL;

	/* Fill the config struct */
	config->frameLength = intarr[1];
	config->compatibleVersion = intarr[2];
	config->bitDepth = intarr[3];
	config->pb = intarr[4];
	config->mb = intarr[5];
	config->kb = intarr[6];
	config->numChannels = intarr[7];
	config->maxRun = intarr[8];
	config->maxFrameBytes = intarr[9];
	config->avgBitRate = intarr[10];
	config->sampleRate = intarr[11];

	/* Validate supported audio types */
	if (config->bitDepth != 16) {
		return -2;
	}
	if (config->numChannels != 2) {
		return -3;
	}

	return 0;
}

static void
set_decoder_info(alac_file *alac, ALACSpecificConfig *config)
{
	unsigned char decoder_info[48];
	memset(decoder_info, 0, sizeof(decoder_info));

#define SET_UINT16(buf, value)do{\
	(buf)[0] = (unsigned char)((value) >> 8);\
	(buf)[1] = (unsigned char)(value);\
	}while(0)

#define SET_UINT32(buf, value)do{\
	(buf)[0] = (unsigned char)((value) >> 24);\
	(buf)[1] = (unsigned char)((value) >> 16);\
	(buf)[2] = (unsigned char)((value) >> 8);\
	(buf)[3] = (unsigned char)(value);\
	}while(0)

	/* Construct decoder info buffer */
	SET_UINT32(&decoder_info[24], config->frameLength);
	decoder_info[28] = config->compatibleVersion;
	decoder_info[29] = config->bitDepth;
	decoder_info[30] = config->pb;
	decoder_info[31] = config->mb;
	decoder_info[32] = config->kb;
	decoder_info[33] = config->numChannels;
	SET_UINT16(&decoder_info[34], config->maxRun);
	SET_UINT32(&decoder_info[36], config->maxFrameBytes);
	SET_UINT32(&decoder_info[40], config->avgBitRate);
	SET_UINT32(&decoder_info[44], config->sampleRate);
	alac_set_info(alac, (char *) decoder_info);
}

raop_buffer_t *
raop_buffer_init(const char *rtpmap,
                 const char *fmtp,
                 const unsigned char *aeskey,
                 const unsigned char *aesiv)
{
	raop_buffer_t *raop_buffer;
	int audio_buffer_size;
	ALACSpecificConfig *alacConfig;
	int i;

        assert(rtpmap);
	assert(fmtp);
	assert(aeskey);
	assert(aesiv);

	raop_buffer = calloc(1, sizeof(raop_buffer_t));
	if (!raop_buffer) {
		return NULL;
	}

	/* Parse fmtp information */
	alacConfig = &raop_buffer->alacConfig;
	if (get_fmtp_info(alacConfig, fmtp) < 0) {
		free(raop_buffer);
		return NULL;
	}

	/* Allocate the output audio buffers */
	audio_buffer_size = alacConfig->frameLength *
	                    alacConfig->numChannels *
	                    alacConfig->bitDepth/8;
	raop_buffer->buffer_size = audio_buffer_size *
	                           RAOP_BUFFER_LENGTH;
	raop_buffer->buffer = malloc(raop_buffer->buffer_size);
	if (!raop_buffer->buffer) {
		free(raop_buffer);
		return NULL;
	}
	for (i=0; i<RAOP_BUFFER_LENGTH; i++) {
		raop_buffer_entry_t *entry = &raop_buffer->entries[i];
		entry->audio_buffer_size = audio_buffer_size;
		entry->audio_buffer_len = 0;
		entry->audio_buffer = (char *)raop_buffer->buffer+i*audio_buffer_size;
	}

	/* Initialize ALAC decoder */
	raop_buffer->alac = create_alac(alacConfig->bitDepth,
	                                alacConfig->numChannels);
	if (!raop_buffer->alac) {
		free(raop_buffer->buffer);
		free(raop_buffer);
		return NULL;
	}
	set_decoder_info(raop_buffer->alac, alacConfig);

	/* Initialize AES keys */
	memcpy(raop_buffer->aeskey, aeskey, RAOP_AESKEY_LEN);
	memcpy(raop_buffer->aesiv, aesiv, RAOP_AESIV_LEN);

	/* Mark buffer as empty */
	raop_buffer->is_empty = 1;
	return raop_buffer;
}

void
raop_buffer_destroy(raop_buffer_t *raop_buffer)
{
	if (raop_buffer) {
		destroy_alac(raop_buffer->alac);
		free(raop_buffer->buffer);
		free(raop_buffer);
	}
}

const ALACSpecificConfig *
raop_buffer_get_config(raop_buffer_t *raop_buffer)
{
	assert(raop_buffer);

	return &raop_buffer->alacConfig;
}

static short
seqnum_cmp(unsigned short s1, unsigned short s2)
{
	return (s1 - s2);
}

int
raop_buffer_queue(raop_buffer_t *raop_buffer, unsigned char *data, unsigned short datalen, int use_seqnum)
{
	unsigned char packetbuf[RAOP_PACKET_LEN];
	unsigned short seqnum;
	raop_buffer_entry_t *entry;
	int encryptedlen;
	AES_CTX aes_ctx;
	int outputlen;

	assert(raop_buffer);

	/* Check packet data length is valid */
	if (datalen < 12 || datalen > RAOP_PACKET_LEN) {
		return -1;
	}

	/* Get correct seqnum for the packet */
	if (use_seqnum) {
		seqnum = (data[2] << 8) | data[3];
	} else {
		seqnum = raop_buffer->first_seqnum;
	}

	/* If this packet is too late, just skip it */
	if (!raop_buffer->is_empty && seqnum_cmp(seqnum, raop_buffer->first_seqnum) < 0) {
		return 0;
	}

	/* Check that there is always space in the buffer, otherwise flush */
	if (seqnum_cmp(seqnum, raop_buffer->first_seqnum+RAOP_BUFFER_LENGTH) >= 0) {
		raop_buffer_flush(raop_buffer, seqnum);
	}

	/* Get entry corresponding our seqnum */
	entry = &raop_buffer->entries[seqnum % RAOP_BUFFER_LENGTH];
	if (entry->available && seqnum_cmp(entry->seqnum, seqnum) == 0) {
		/* Packet resend, we can safely ignore */
		return 0;
	}

	/* Update the raop_buffer entry header */
	entry->flags = data[0];
	entry->type = data[1];
	entry->seqnum = seqnum;
	entry->timestamp = (data[4] << 24) | (data[5] << 16) |
	                   (data[6] << 8) | data[7];
	entry->ssrc = (data[8] << 24) | (data[9] << 16) |
	              (data[10] << 8) | data[11];
	entry->available = 1;

	/* Decrypt audio data */
	encryptedlen = (datalen-12)/16*16;
	AES_set_key(&aes_ctx, raop_buffer->aeskey, raop_buffer->aesiv, AES_MODE_128);
	AES_convert_key(&aes_ctx);
	AES_cbc_decrypt(&aes_ctx, &data[12], packetbuf, encryptedlen);
	memcpy(packetbuf+encryptedlen, &data[12+encryptedlen], datalen-12-encryptedlen);

	/* Decode ALAC audio data */
	outputlen = entry->audio_buffer_size;
	decode_frame(raop_buffer->alac, packetbuf, entry->audio_buffer, &outputlen);
	entry->audio_buffer_len = outputlen;

	/* Update the raop_buffer seqnums */
	if (raop_buffer->is_empty) {
		raop_buffer->first_seqnum = seqnum;
		raop_buffer->last_seqnum = seqnum;
		raop_buffer->is_empty = 0;
	}
	if (seqnum_cmp(seqnum, raop_buffer->last_seqnum) > 0) {
		raop_buffer->last_seqnum = seqnum;
	}
	return 1;
}

const void *
raop_buffer_dequeue(raop_buffer_t *raop_buffer, int *length, int no_resend)
{
	short buflen;
	raop_buffer_entry_t *entry;

	/* Calculate number of entries in the current buffer */
	buflen = seqnum_cmp(raop_buffer->last_seqnum, raop_buffer->first_seqnum)+1;

	/* Cannot dequeue from empty buffer */
	if (raop_buffer->is_empty || buflen <= 0) {
		return NULL;
	}

	/* Get the first buffer entry for inspection */
	entry = &raop_buffer->entries[raop_buffer->first_seqnum % RAOP_BUFFER_LENGTH];
	if (no_resend) {
		/* If we do no resends, always return the first entry */
	} else if (!entry->available) {
		/* Check how much we have space left in the buffer */
		if (buflen < RAOP_BUFFER_LENGTH) {
			/* Return nothing and hope resend gets on time */
			return NULL;
		}
		/* Risk of buffer overrun, return empty buffer */
	}

	/* Update buffer and validate entry */
	raop_buffer->first_seqnum += 1;
	if (!entry->available) {
		/* Return an empty audio buffer to skip audio */
		*length = entry->audio_buffer_size;
		memset(entry->audio_buffer, 0, *length);
		return entry->audio_buffer;
	}
	entry->available = 0;

	/* Return entry audio buffer */
	*length = entry->audio_buffer_len;
	entry->audio_buffer_len = 0;
	return entry->audio_buffer;
}

void
raop_buffer_handle_resends(raop_buffer_t *raop_buffer, raop_resend_cb_t resend_cb, void *opaque)
{
	raop_buffer_entry_t *entry;

	assert(raop_buffer);
	assert(resend_cb);

	if (seqnum_cmp(raop_buffer->first_seqnum, raop_buffer->last_seqnum) < 0) {
		int seqnum, count;

		for (seqnum=raop_buffer->first_seqnum; seqnum_cmp(seqnum, raop_buffer->last_seqnum)<0; seqnum++) {
			entry = &raop_buffer->entries[seqnum % RAOP_BUFFER_LENGTH];
			if (entry->available) {
				break;
			}
		}
		if (seqnum_cmp(seqnum, raop_buffer->first_seqnum) == 0) {
			return;
		}
		count = seqnum_cmp(seqnum, raop_buffer->first_seqnum);
		resend_cb(opaque, raop_buffer->first_seqnum, count);
	}
}

void
raop_buffer_flush(raop_buffer_t *raop_buffer, int next_seq)
{
	int i;

	assert(raop_buffer);

	for (i=0; i<RAOP_BUFFER_LENGTH; i++) {
		raop_buffer->entries[i].available = 0;
		raop_buffer->entries[i].audio_buffer_len = 0;
	}
	if (next_seq < 0 || next_seq > 0xffff) {
		raop_buffer->is_empty = 1;
	} else {
		raop_buffer->first_seqnum = next_seq;
		raop_buffer->last_seqnum = next_seq-1;
	}
}
Commit	Line	Data
23e7e3ae JVH	1	/**
	2	* Copyright (C) 2011-2012 Juho Vähä-Herttua
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Lesser General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2.1 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Lesser General Public License for more details.
	13	*/
	14
2340bcd3 JVH	15	#include <stdlib.h>
	16	#include <string.h>
	17	#include <assert.h>
	18	#include <math.h>
	19
	20	#include "raop_buffer.h"
	21	#include "raop_rtp.h"
	22	#include "utils.h"
	23
	24	#include <stdint.h>
	25	#include "crypto/crypto.h"
	26	#include "alac/alac.h"
	27
	28	#define RAOP_BUFFER_LENGTH 16
	29
	30	typedef struct {
	31	/* Packet available */
	32	int available;
	33
	34	/* RTP header */
	35	unsigned char flags;
	36	unsigned char type;
	37	unsigned short seqnum;
	38	unsigned int timestamp;
	39	unsigned int ssrc;
	40
	41	/* Audio buffer of valid length */
	42	int audio_buffer_size;
	43	int audio_buffer_len;
	44	void *audio_buffer;
	45	} raop_buffer_entry_t;
	46
	47	struct raop_buffer_s {
	48	/* AES key and IV */
	49	unsigned char aeskey[RAOP_AESKEY_LEN];
	50	unsigned char aesiv[RAOP_AESIV_LEN];
	51
	52	/* ALAC decoder */
	53	ALACSpecificConfig alacConfig;
	54	alac_file *alac;
	55
	56	/* First and last seqnum */
	57	int is_empty;
	58	unsigned short first_seqnum;
	59	unsigned short last_seqnum;
	60
	61	/* RTP buffer entries */
	62	raop_buffer_entry_t entries[RAOP_BUFFER_LENGTH];
	63
	64	/* Buffer of all audio buffers */
	65	int buffer_size;
	66	void *buffer;
	67	};
	68
	69
	70
	71	static int
	72	get_fmtp_info(ALACSpecificConfig config, const char fmtp)
	73	{
	74	int intarr[12];
a5670bb8	75	char *original;
2340bcd3 JVH	76	char *strptr;
	77	int i;
	78
	79	/* Parse fmtp string to integers */
a5670bb8	80	original = strptr = strdup(fmtp);
2340bcd3 JVH	81	for (i=0; i<12; i++) {
2340bcd3 JVH	82	if (strptr == NULL) {
a5670bb8	83	free(original);
2340bcd3 JVH	84	return -1;
	85	}
	86	intarr[i] = atoi(utils_strsep(&strptr, " "));
	87	}
a5670bb8 JVH	88	free(original);
a5670bb8 JVH	89	original = strptr = NULL;
2340bcd3 JVH	90
	91	/* Fill the config struct */
	92	config->frameLength = intarr[1];
	93	config->compatibleVersion = intarr[2];
	94	config->bitDepth = intarr[3];
	95	config->pb = intarr[4];
	96	config->mb = intarr[5];
	97	config->kb = intarr[6];
	98	config->numChannels = intarr[7];
	99	config->maxRun = intarr[8];
	100	config->maxFrameBytes = intarr[9];
	101	config->avgBitRate = intarr[10];
	102	config->sampleRate = intarr[11];
	103
	104	/* Validate supported audio types */
	105	if (config->bitDepth != 16) {
	106	return -2;
	107	}
	108	if (config->numChannels != 2) {
	109	return -3;
	110	}
	111
	112	return 0;
	113	}
	114
	115	static void
	116	set_decoder_info(alac_file alac, ALACSpecificConfig config)
	117	{
	118	unsigned char decoder_info[48];
	119	memset(decoder_info, 0, sizeof(decoder_info));
	120
	121	#define SET_UINT16(buf, value)do{\
	122	(buf)[0] = (unsigned char)((value) >> 8);\
	123	(buf)[1] = (unsigned char)(value);\
	124	}while(0)
	125
	126	#define SET_UINT32(buf, value)do{\
	127	(buf)[0] = (unsigned char)((value) >> 24);\
	128	(buf)[1] = (unsigned char)((value) >> 16);\
	129	(buf)[2] = (unsigned char)((value) >> 8);\
	130	(buf)[3] = (unsigned char)(value);\
	131	}while(0)
	132
	133	/* Construct decoder info buffer */
	134	SET_UINT32(&decoder_info[24], config->frameLength);
	135	decoder_info[28] = config->compatibleVersion;
	136	decoder_info[29] = config->bitDepth;
	137	decoder_info[30] = config->pb;
	138	decoder_info[31] = config->mb;
	139	decoder_info[32] = config->kb;
	140	decoder_info[33] = config->numChannels;
	141	SET_UINT16(&decoder_info[34], config->maxRun);
	142	SET_UINT32(&decoder_info[36], config->maxFrameBytes);
	143	SET_UINT32(&decoder_info[40], config->avgBitRate);
	144	SET_UINT32(&decoder_info[44], config->sampleRate);
	145	alac_set_info(alac, (char *) decoder_info);
	146	}
	147
	148	raop_buffer_t *
597bc69b JVH	149	raop_buffer_init(const char *rtpmap,
597bc69b JVH	150	const char *fmtp,
2340bcd3 JVH	151	const unsigned char *aeskey,
	152	const unsigned char *aesiv)
	153	{
	154	raop_buffer_t *raop_buffer;
	155	int audio_buffer_size;
	156	ALACSpecificConfig *alacConfig;
	157	int i;
	158
597bc69b	159	assert(rtpmap);
2340bcd3 JVH	160	assert(fmtp);
	161	assert(aeskey);
	162	assert(aesiv);
	163
	164	raop_buffer = calloc(1, sizeof(raop_buffer_t));
	165	if (!raop_buffer) {
	166	return NULL;
	167	}
	168
	169	/* Parse fmtp information */
	170	alacConfig = &raop_buffer->alacConfig;
	171	if (get_fmtp_info(alacConfig, fmtp) < 0) {
	172	free(raop_buffer);
	173	return NULL;
	174	}
	175
	176	/* Allocate the output audio buffers */
	177	audio_buffer_size = alacConfig->frameLength *
	178	alacConfig->numChannels *
	179	alacConfig->bitDepth/8;
	180	raop_buffer->buffer_size = audio_buffer_size *
	181	RAOP_BUFFER_LENGTH;
	182	raop_buffer->buffer = malloc(raop_buffer->buffer_size);
	183	if (!raop_buffer->buffer) {
	184	free(raop_buffer);
	185	return NULL;
	186	}
	187	for (i=0; i<RAOP_BUFFER_LENGTH; i++) {
	188	raop_buffer_entry_t *entry = &raop_buffer->entries[i];
	189	entry->audio_buffer_size = audio_buffer_size;
	190	entry->audio_buffer_len = 0;
566c9bf8	191	entry->audio_buffer = (char )raop_buffer->buffer+iaudio_buffer_size;
2340bcd3 JVH	192	}
	193
	194	/* Initialize ALAC decoder */
	195	raop_buffer->alac = create_alac(alacConfig->bitDepth,
	196	alacConfig->numChannels);
	197	if (!raop_buffer->alac) {
	198	free(raop_buffer->buffer);
	199	free(raop_buffer);
	200	return NULL;
	201	}
	202	set_decoder_info(raop_buffer->alac, alacConfig);
	203
	204	/* Initialize AES keys */
	205	memcpy(raop_buffer->aeskey, aeskey, RAOP_AESKEY_LEN);
	206	memcpy(raop_buffer->aesiv, aesiv, RAOP_AESIV_LEN);
	207
	208	/* Mark buffer as empty */
	209	raop_buffer->is_empty = 1;
	210	return raop_buffer;
	211	}
	212
	213	void
	214	raop_buffer_destroy(raop_buffer_t *raop_buffer)
	215	{
	216	if (raop_buffer) {
982a0c26	217	destroy_alac(raop_buffer->alac);
2340bcd3	218	free(raop_buffer->buffer);
2340bcd3 JVH	219	free(raop_buffer);
	220	}
	221	}
	222
	223	const ALACSpecificConfig *
	224	raop_buffer_get_config(raop_buffer_t *raop_buffer)
	225	{
	226	assert(raop_buffer);
	227
	228	return &raop_buffer->alacConfig;
	229	}
	230
	231	static short
	232	seqnum_cmp(unsigned short s1, unsigned short s2)
	233	{
	234	return (s1 - s2);
	235	}
	236
	237	int
	238	raop_buffer_queue(raop_buffer_t raop_buffer, unsigned char data, unsigned short datalen, int use_seqnum)
	239	{
	240	unsigned char packetbuf[RAOP_PACKET_LEN];
	241	unsigned short seqnum;
	242	raop_buffer_entry_t *entry;
	243	int encryptedlen;
	244	AES_CTX aes_ctx;
	245	int outputlen;
	246
	247	assert(raop_buffer);
	248
	249	/* Check packet data length is valid */
	250	if (datalen < 12 \|\| datalen > RAOP_PACKET_LEN) {
	251	return -1;
	252	}
	253
	254	/* Get correct seqnum for the packet */
	255	if (use_seqnum) {
	256	seqnum = (data[2] << 8) \| data[3];
	257	} else {
	258	seqnum = raop_buffer->first_seqnum;
	259	}
	260
	261	/* If this packet is too late, just skip it */
	262	if (!raop_buffer->is_empty && seqnum_cmp(seqnum, raop_buffer->first_seqnum) < 0) {
	263	return 0;
	264	}
	265
	266	/* Check that there is always space in the buffer, otherwise flush */
	267	if (seqnum_cmp(seqnum, raop_buffer->first_seqnum+RAOP_BUFFER_LENGTH) >= 0) {
	268	raop_buffer_flush(raop_buffer, seqnum);
	269	}
	270
	271	/* Get entry corresponding our seqnum */
	272	entry = &raop_buffer->entries[seqnum % RAOP_BUFFER_LENGTH];
	273	if (entry->available && seqnum_cmp(entry->seqnum, seqnum) == 0) {
	274	/* Packet resend, we can safely ignore */
	275	return 0;
	276	}
	277
	278	/* Update the raop_buffer entry header */
	279	entry->flags = data[0];
	280	entry->type = data[1];
	281	entry->seqnum = seqnum;
	282	entry->timestamp = (data[4] << 24) \| (data[5] << 16) \|
283	(data[6] << 8) \| data[7];
284	entry->ssrc = (data[8] << 24) \| (data[9] << 16) \|
285	(data[10] << 8) \| data[11];
286	entry->available = 1;
287
288	/* Decrypt audio data */
289	encryptedlen = (datalen-12)/16*16;
290	AES_set_key(&aes_ctx, raop_buffer->aeskey, raop_buffer->aesiv, AES_MODE_128);
291	AES_convert_key(&aes_ctx);
292	AES_cbc_decrypt(&aes_ctx, &data[12], packetbuf, encryptedlen);
293	memcpy(packetbuf+encryptedlen, &data[12+encryptedlen], datalen-12-encryptedlen);
294
295	/* Decode ALAC audio data */
296	outputlen = entry->audio_buffer_size;
297	decode_frame(raop_buffer->alac, packetbuf, entry->audio_buffer, &outputlen);
298	entry->audio_buffer_len = outputlen;
299
300	/* Update the raop_buffer seqnums */
301	if (raop_buffer->is_empty) {
302	raop_buffer->first_seqnum = seqnum;
303	raop_buffer->last_seqnum = seqnum;
304	raop_buffer->is_empty = 0;
305	}
306	if (seqnum_cmp(seqnum, raop_buffer->last_seqnum) > 0) {
307	raop_buffer->last_seqnum = seqnum;
308	}
309	return 1;
310	}
311
312	const void *
313	raop_buffer_dequeue(raop_buffer_t raop_buffer, int length, int no_resend)
314	{
315	short buflen;
316	raop_buffer_entry_t *entry;
317
318	/* Calculate number of entries in the current buffer */
319	buflen = seqnum_cmp(raop_buffer->last_seqnum, raop_buffer->first_seqnum)+1;
320
321	/* Cannot dequeue from empty buffer */
322	if (raop_buffer->is_empty \|\| buflen <= 0) {
323	return NULL;
324	}
325
326	/* Get the first buffer entry for inspection */
327	entry = &raop_buffer->entries[raop_buffer->first_seqnum % RAOP_BUFFER_LENGTH];
328	if (no_resend) {
329	/* If we do no resends, always return the first entry */
330	} else if (!entry->available) {
331	/* Check how much we have space left in the buffer */
332	if (buflen < RAOP_BUFFER_LENGTH) {
333	/* Return nothing and hope resend gets on time */
334	return NULL;
335	}
336	/* Risk of buffer overrun, return empty buffer */
337	}
338
339	/* Update buffer and validate entry */
340	raop_buffer->first_seqnum += 1;
341	if (!entry->available) {
342	/* Return an empty audio buffer to skip audio */
343	*length = entry->audio_buffer_size;
344	memset(entry->audio_buffer, 0, *length);
345	return entry->audio_buffer;
346	}
347	entry->available = 0;
348
349	/* Return entry audio buffer */
350	*length = entry->audio_buffer_len;
351	entry->audio_buffer_len = 0;
352	return entry->audio_buffer;
353	}
354
355	void
356	raop_buffer_handle_resends(raop_buffer_t raop_buffer, raop_resend_cb_t resend_cb, void opaque)
357	{
358	raop_buffer_entry_t *entry;
359
360	assert(raop_buffer);
361	assert(resend_cb);
362
363	if (seqnum_cmp(raop_buffer->first_seqnum, raop_buffer->last_seqnum) < 0) {
364	int seqnum, count;
365
366	for (seqnum=raop_buffer->first_seqnum; seqnum_cmp(seqnum, raop_buffer->last_seqnum)<0; seqnum++) {
367	entry = &raop_buffer->entries[seqnum % RAOP_BUFFER_LENGTH];
368	if (entry->available) {
369	break;
370	}
371	}
372	if (seqnum_cmp(seqnum, raop_buffer->first_seqnum) == 0) {
373	return;
374	}
375	count = seqnum_cmp(seqnum, raop_buffer->first_seqnum);
376	resend_cb(opaque, raop_buffer->first_seqnum, count);
377	}
378	}
379
380	void
381	raop_buffer_flush(raop_buffer_t *raop_buffer, int next_seq)
382	{
383	int i;
384
385	assert(raop_buffer);
386
387	for (i=0; i<RAOP_BUFFER_LENGTH; i++) {
388	raop_buffer->entries[i].available = 0;
389	raop_buffer->entries[i].audio_buffer_len = 0;
390	}
391	if (next_seq < 0 \|\| next_seq > 0xffff) {
392	raop_buffer->is_empty = 1;
393	} else {
394	raop_buffer->first_seqnum = next_seq;
395	raop_buffer->last_seqnum = next_seq-1;
396	}
397	}