trunk/rdesktop/rdpsnd.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   Sound Channel Process Functions
   Copyright (C) Matthew Chapman 2003
   Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003

   This program 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.

   This program 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 this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "rdesktop.h"
#include "rdpsnd.h"

#define RDPSND_CLOSE            1
#define RDPSND_WRITE            2
#define RDPSND_SET_VOLUME       3
#define RDPSND_UNKNOWN4         4
#define RDPSND_COMPLETION       5
#define RDPSND_SERVERTICK       6
#define RDPSND_NEGOTIATE        7

#define MAX_FORMATS             10
#define MAX_QUEUE               10

BOOL g_dsp_busy = False;
int g_dsp_fd;

static VCHANNEL *rdpsnd_channel;
static struct audio_driver *drivers = NULL;
struct audio_driver *current_driver = NULL;

static BOOL device_open;
static WAVEFORMATEX formats[MAX_FORMATS];
static unsigned int format_count;
static unsigned int current_format;
unsigned int queue_hi, queue_lo;
struct audio_packet packet_queue[MAX_QUEUE];

void (*wave_out_play) (void);

static STREAM
rdpsnd_init_packet(uint16 type, uint16 size)
{
        STREAM s;

        s = channel_init(rdpsnd_channel, size + 4);
        out_uint16_le(s, type);
        out_uint16_le(s, size);
        return s;
}

static void
rdpsnd_send(STREAM s)
{
#ifdef RDPSND_DEBUG
        printf("RDPSND send:\n");
        hexdump(s->channel_hdr + 8, s->end - s->channel_hdr - 8);
#endif

        channel_send(s, rdpsnd_channel);
}

void
rdpsnd_send_completion(uint16 tick, uint8 packet_index)
{
        STREAM s;

        s = rdpsnd_init_packet(RDPSND_COMPLETION, 4);
        out_uint16_le(s, tick);
        out_uint8(s, packet_index);
        out_uint8(s, 0);
        s_mark_end(s);
        rdpsnd_send(s);
}

static void
rdpsnd_process_negotiate(STREAM in)
{
        unsigned int in_format_count, i;
        WAVEFORMATEX *format;
        STREAM out;
        BOOL device_available = False;
        int readcnt;
        int discardcnt;

        in_uint8s(in, 14);      /* flags, volume, pitch, UDP port */
        in_uint16_le(in, in_format_count);
        in_uint8s(in, 4);       /* pad, status, pad */

        if (current_driver->wave_out_open())
        {
                current_driver->wave_out_close();
                device_available = True;
        }

        format_count = 0;
        if (s_check_rem(in, 18 * in_format_count))
        {
                for (i = 0; i < in_format_count; i++)
                {
                        format = &formats[format_count];
                        in_uint16_le(in, format->wFormatTag);
                        in_uint16_le(in, format->nChannels);
                        in_uint32_le(in, format->nSamplesPerSec);
                        in_uint32_le(in, format->nAvgBytesPerSec);
                        in_uint16_le(in, format->nBlockAlign);
                        in_uint16_le(in, format->wBitsPerSample);
                        in_uint16_le(in, format->cbSize);

                        /* read in the buffer of unknown use */
                        readcnt = format->cbSize;
                        discardcnt = 0;
                        if (format->cbSize > MAX_CBSIZE)
                        {
                                fprintf(stderr, "cbSize too large for buffer: %d\n",
                                        format->cbSize);
                                readcnt = MAX_CBSIZE;
                                discardcnt = format->cbSize - MAX_CBSIZE;
                        }
                        in_uint8a(in, format->cb, readcnt);
                        in_uint8s(in, discardcnt);

                        if (device_available && current_driver->wave_out_format_supported(format))
                        {
                                format_count++;
                                if (format_count == MAX_FORMATS)
                                        break;
                        }
                }
        }

        out = rdpsnd_init_packet(RDPSND_NEGOTIATE | 0x200, 20 + 18 * format_count);
        out_uint32_le(out, 3);  /* flags */
        out_uint32(out, 0xffffffff);    /* volume */
        out_uint32(out, 0);     /* pitch */
        out_uint16(out, 0);     /* UDP port */

        out_uint16_le(out, format_count);
        out_uint8(out, 0x95);   /* pad? */
        out_uint16_le(out, 2);  /* status */
        out_uint8(out, 0x77);   /* pad? */

        for (i = 0; i < format_count; i++)
        {
                format = &formats[i];
                out_uint16_le(out, format->wFormatTag);
                out_uint16_le(out, format->nChannels);
                out_uint32_le(out, format->nSamplesPerSec);
                out_uint32_le(out, format->nAvgBytesPerSec);
                out_uint16_le(out, format->nBlockAlign);
                out_uint16_le(out, format->wBitsPerSample);
                out_uint16(out, 0);     /* cbSize */
        }

        s_mark_end(out);
        rdpsnd_send(out);
}

static void
rdpsnd_process_servertick(STREAM in)
{
        uint16 tick1, tick2;
        STREAM out;

        /* in_uint8s(in, 4); unknown */
        in_uint16_le(in, tick1);
        in_uint16_le(in, tick2);

        out = rdpsnd_init_packet(RDPSND_SERVERTICK | 0x2300, 4);
        out_uint16_le(out, tick1);
        out_uint16_le(out, tick2);
        s_mark_end(out);
        rdpsnd_send(out);
}

static void
rdpsnd_process(STREAM s)
{
        uint8 type;
        uint16 datalen;
        uint32 volume;
        static uint16 tick, format;
        static uint8 packet_index;
        static BOOL awaiting_data_packet;

#ifdef RDPSND_DEBUG
        printf("RDPSND recv:\n");
        hexdump(s->p, s->end - s->p);
#endif

        if (awaiting_data_packet)
        {
                if (format >= MAX_FORMATS)
                {
                        error("RDPSND: Invalid format index\n");
                        return;
                }

                if (!device_open || (format != current_format))
                {
                        if (!device_open && !current_driver->wave_out_open())
                        {
                                rdpsnd_send_completion(tick, packet_index);
                                return;
                        }
                        if (!current_driver->wave_out_set_format(&formats[format]))
                        {
                                rdpsnd_send_completion(tick, packet_index);
                                current_driver->wave_out_close();
                                device_open = False;
                                return;
                        }
                        device_open = True;
                        current_format = format;
                }

                current_driver->wave_out_write(s, tick, packet_index);
                awaiting_data_packet = False;
                return;
        }

        in_uint8(s, type);
        in_uint8s(s, 1);        /* unknown? */
        in_uint16_le(s, datalen);

        switch (type)
        {
                case RDPSND_WRITE:
                        in_uint16_le(s, tick);
                        in_uint16_le(s, format);
                        in_uint8(s, packet_index);
                        awaiting_data_packet = True;
                        break;
                case RDPSND_CLOSE:
                        current_driver->wave_out_close();
                        device_open = False;
                        break;
                case RDPSND_NEGOTIATE:
                        rdpsnd_process_negotiate(s);
                        break;
                case RDPSND_SERVERTICK:
                        rdpsnd_process_servertick(s);
                        break;
                case RDPSND_SET_VOLUME:
                        in_uint32(s, volume);
                        if (device_open)
                        {
                                current_driver->wave_out_volume((volume & 0xffff),
                                                                (volume & 0xffff0000) >> 16);
                        }
                        break;
                default:
                        unimpl("RDPSND packet type %d\n", type);
                        break;
        }
}

BOOL
rdpsnd_init(void)
{
        rdpsnd_channel =
                channel_register("rdpsnd", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP,
                                 rdpsnd_process);

        return (rdpsnd_channel != NULL);
}

BOOL
rdpsnd_auto_open(void)
{
        current_driver = drivers;
        while (current_driver != NULL)
        {
                DEBUG(("trying %s...\n", current_driver->name));
                if (current_driver->wave_out_open())
                {
                        DEBUG(("selected %s\n", current_driver->name));
                        return True;
                }
                g_dsp_fd = 0;
                current_driver = current_driver->next;
        }

        warning("no working audio-driver found\n");

        return False;
}

void
rdpsnd_register_drivers(char *options)
{
        struct audio_driver **reg;

        /* The order of registrations define the probe-order
           when opening the device for the first time */
        reg = &drivers;
#if defined(RDPSND_ALSA)
        *reg = alsa_register(options);
        reg = &((*reg)->next);
#endif
#if defined(RDPSND_OSS)
        *reg = oss_register(options);
        reg = &((*reg)->next);
#endif
#if defined(RDPSND_SUN)
        *reg = sun_register(options);
        reg = &((*reg)->next);
#endif
#if defined(RDPSND_SGI)
        *reg = sgi_register(options);
        reg = &((*reg)->next);
#endif
#if defined(RDPSND_LIBAO)
        *reg = libao_register(options);
        reg = &((*reg)->next);
#endif
}

BOOL
rdpsnd_select_driver(char *driver, char *options)
{
        static struct audio_driver auto_driver;
        struct audio_driver *pos;

        drivers = NULL;
        rdpsnd_register_drivers(options);

        if (!driver)
        {
                auto_driver.wave_out_open = &rdpsnd_auto_open;
                current_driver = &auto_driver;
                return True;
        }

        pos = drivers;
        while (pos != NULL)
        {
                if (!strcmp(pos->name, driver))
                {
                        DEBUG(("selected %s\n", pos->name));
                        current_driver = pos;
                        return True;
                }
                pos = pos->next;
        }
        return False;
}

void
rdpsnd_show_help(void)
{
        struct audio_driver *pos;

        rdpsnd_register_drivers(NULL);

        pos = drivers;
        while (pos != NULL)
        {
                fprintf(stderr, "                     %s:\t%s\n", pos->name, pos->description);
                pos = pos->next;
        }
}

inline void
rdpsnd_play(void)
{
        current_driver->wave_out_play();
}

void
rdpsnd_queue_write(STREAM s, uint16 tick, uint8 index)
{
        struct audio_packet *packet = &packet_queue[queue_hi];
        unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;

        if (next_hi == queue_lo)
        {
                error("No space to queue audio packet\n");
                return;
        }

        queue_hi = next_hi;

        packet->s = *s;
        packet->tick = tick;
        packet->index = index;
        packet->s.p += 4;

        /* we steal the data buffer from s, give it a new one */
        s->data = malloc(s->size);

        if (!g_dsp_busy)
                current_driver->wave_out_play();
}

inline struct audio_packet *
rdpsnd_queue_current_packet(void)
{
        return &packet_queue[queue_lo];
}

inline BOOL
rdpsnd_queue_empty(void)
{
        return (queue_lo == queue_hi);
}

inline void
rdpsnd_queue_init(void)
{
        queue_lo = queue_hi = 0;
}

inline void
rdpsnd_queue_next(void)
{
        free(packet_queue[queue_lo].s.data);
        queue_lo = (queue_lo + 1) % MAX_QUEUE;
}

inline int
rdpsnd_queue_next_tick(void)
{
        if (((queue_lo + 1) % MAX_QUEUE) != queue_hi)
        {
                return packet_queue[(queue_lo + 1) % MAX_QUEUE].tick;
        }
        else
        {
                return (packet_queue[queue_lo].tick + 65535) % 65536;
        }
}
1	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3	Sound Channel Process Functions
4	Copyright (C) Matthew Chapman 2003
5	Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20	*/
21
22	#include "rdesktop.h"
23	#include "rdpsnd.h"
24
25	#define RDPSND_CLOSE 1
26	#define RDPSND_WRITE 2
27	#define RDPSND_SET_VOLUME 3
28	#define RDPSND_UNKNOWN4 4
29	#define RDPSND_COMPLETION 5
30	#define RDPSND_SERVERTICK 6
31	#define RDPSND_NEGOTIATE 7
32
33	#define MAX_FORMATS 10
34	#define MAX_QUEUE 10
35
36	BOOL g_dsp_busy = False;
37	int g_dsp_fd;
38
39	static VCHANNEL *rdpsnd_channel;
40	static struct audio_driver *drivers = NULL;
41	struct audio_driver *current_driver = NULL;
42
43	static BOOL device_open;
44	static WAVEFORMATEX formats[MAX_FORMATS];
45	static unsigned int format_count;
46	static unsigned int current_format;
47	unsigned int queue_hi, queue_lo;
48	struct audio_packet packet_queue[MAX_QUEUE];
49
50	void (*wave_out_play) (void);
51
52	static STREAM
53	rdpsnd_init_packet(uint16 type, uint16 size)
54	{
55	STREAM s;
56
57	s = channel_init(rdpsnd_channel, size + 4);
58	out_uint16_le(s, type);
59	out_uint16_le(s, size);
60	return s;
61	}
62
63	static void
64	rdpsnd_send(STREAM s)
65	{
66	#ifdef RDPSND_DEBUG
67	printf("RDPSND send:\n");
68	hexdump(s->channel_hdr + 8, s->end - s->channel_hdr - 8);
69	#endif
70
71	channel_send(s, rdpsnd_channel);
72	}
73
74	void
75	rdpsnd_send_completion(uint16 tick, uint8 packet_index)
76	{
77	STREAM s;
78
79	s = rdpsnd_init_packet(RDPSND_COMPLETION, 4);
80	out_uint16_le(s, tick);
81	out_uint8(s, packet_index);
82	out_uint8(s, 0);
83	s_mark_end(s);
84	rdpsnd_send(s);
85	}
86
87	static void
88	rdpsnd_process_negotiate(STREAM in)
89	{
90	unsigned int in_format_count, i;
91	WAVEFORMATEX *format;
92	STREAM out;
93	BOOL device_available = False;
94	int readcnt;
95	int discardcnt;
96
97	in_uint8s(in, 14); /* flags, volume, pitch, UDP port */
98	in_uint16_le(in, in_format_count);
99	in_uint8s(in, 4); /* pad, status, pad */
100
101	if (current_driver->wave_out_open())
102	{
103	current_driver->wave_out_close();
104	device_available = True;
105	}
106
107	format_count = 0;
108	if (s_check_rem(in, 18 * in_format_count))
109	{
110	for (i = 0; i < in_format_count; i++)
111	{
112	format = &formats[format_count];
113	in_uint16_le(in, format->wFormatTag);
114	in_uint16_le(in, format->nChannels);
115	in_uint32_le(in, format->nSamplesPerSec);
116	in_uint32_le(in, format->nAvgBytesPerSec);
117	in_uint16_le(in, format->nBlockAlign);
118	in_uint16_le(in, format->wBitsPerSample);
119	in_uint16_le(in, format->cbSize);
120
121	/* read in the buffer of unknown use */
122	readcnt = format->cbSize;
123	discardcnt = 0;
124	if (format->cbSize > MAX_CBSIZE)
125	{
126	fprintf(stderr, "cbSize too large for buffer: %d\n",
127	format->cbSize);
128	readcnt = MAX_CBSIZE;
129	discardcnt = format->cbSize - MAX_CBSIZE;
130	}
131	in_uint8a(in, format->cb, readcnt);
132	in_uint8s(in, discardcnt);
133
134	if (device_available && current_driver->wave_out_format_supported(format))
135	{
136	format_count++;
137	if (format_count == MAX_FORMATS)
138	break;
139	}
140	}
141	}
142
143	out = rdpsnd_init_packet(RDPSND_NEGOTIATE \| 0x200, 20 + 18 * format_count);
144	out_uint32_le(out, 3); /* flags */
145	out_uint32(out, 0xffffffff); /* volume */
146	out_uint32(out, 0); /* pitch */
147	out_uint16(out, 0); /* UDP port */
148
149	out_uint16_le(out, format_count);
150	out_uint8(out, 0x95); /* pad? */
151	out_uint16_le(out, 2); /* status */
152	out_uint8(out, 0x77); /* pad? */
153
154	for (i = 0; i < format_count; i++)
155	{
156	format = &formats[i];
157	out_uint16_le(out, format->wFormatTag);
158	out_uint16_le(out, format->nChannels);
159	out_uint32_le(out, format->nSamplesPerSec);
160	out_uint32_le(out, format->nAvgBytesPerSec);
161	out_uint16_le(out, format->nBlockAlign);
162	out_uint16_le(out, format->wBitsPerSample);
163	out_uint16(out, 0); /* cbSize */
164	}
165
166	s_mark_end(out);
167	rdpsnd_send(out);
168	}
169
170	static void
171	rdpsnd_process_servertick(STREAM in)
172	{
173	uint16 tick1, tick2;
174	STREAM out;
175
176	/* in_uint8s(in, 4); unknown */
177	in_uint16_le(in, tick1);
178	in_uint16_le(in, tick2);
179
180	out = rdpsnd_init_packet(RDPSND_SERVERTICK \| 0x2300, 4);
181	out_uint16_le(out, tick1);
182	out_uint16_le(out, tick2);
183	s_mark_end(out);
184	rdpsnd_send(out);
185	}
186
187	static void
188	rdpsnd_process(STREAM s)
189	{
190	uint8 type;
191	uint16 datalen;
192	uint32 volume;
193	static uint16 tick, format;
194	static uint8 packet_index;
195	static BOOL awaiting_data_packet;
196
197	#ifdef RDPSND_DEBUG
198	printf("RDPSND recv:\n");
199	hexdump(s->p, s->end - s->p);
200	#endif
201
202	if (awaiting_data_packet)
203	{
204	if (format >= MAX_FORMATS)
205	{
206	error("RDPSND: Invalid format index\n");
207	return;
208	}
209
210	if (!device_open \|\| (format != current_format))
211	{
212	if (!device_open && !current_driver->wave_out_open())
213	{
214	rdpsnd_send_completion(tick, packet_index);
215	return;
216	}
217	if (!current_driver->wave_out_set_format(&formats[format]))
218	{
219	rdpsnd_send_completion(tick, packet_index);
220	current_driver->wave_out_close();
221	device_open = False;
222	return;
223	}
224	device_open = True;
225	current_format = format;
226	}
227
228	current_driver->wave_out_write(s, tick, packet_index);
229	awaiting_data_packet = False;
230	return;
231	}
232
233	in_uint8(s, type);
234	in_uint8s(s, 1); /* unknown? */
235	in_uint16_le(s, datalen);
236
237	switch (type)
238	{
239	case RDPSND_WRITE:
240	in_uint16_le(s, tick);
241	in_uint16_le(s, format);
242	in_uint8(s, packet_index);
243	awaiting_data_packet = True;
244	break;
245	case RDPSND_CLOSE:
246	current_driver->wave_out_close();
247	device_open = False;
248	break;
249	case RDPSND_NEGOTIATE:
250	rdpsnd_process_negotiate(s);
251	break;
252	case RDPSND_SERVERTICK:
253	rdpsnd_process_servertick(s);
254	break;
255	case RDPSND_SET_VOLUME:
256	in_uint32(s, volume);
257	if (device_open)
258	{
259	current_driver->wave_out_volume((volume & 0xffff),
260	(volume & 0xffff0000) >> 16);
261	}
262	break;
263	default:
264	unimpl("RDPSND packet type %d\n", type);
265	break;
266	}
267	}
268
269	BOOL
270	rdpsnd_init(void)
271	{
272	rdpsnd_channel =
273	channel_register("rdpsnd", CHANNEL_OPTION_INITIALIZED \| CHANNEL_OPTION_ENCRYPT_RDP,
274	rdpsnd_process);
275
276	return (rdpsnd_channel != NULL);
277	}
278
279	BOOL
280	rdpsnd_auto_open(void)
281	{
282	current_driver = drivers;
283	while (current_driver != NULL)
284	{
285	DEBUG(("trying %s...\n", current_driver->name));
286	if (current_driver->wave_out_open())
287	{
288	DEBUG(("selected %s\n", current_driver->name));
289	return True;
290	}
291	g_dsp_fd = 0;
292	current_driver = current_driver->next;
293	}
294
295	warning("no working audio-driver found\n");
296
297	return False;
298	}
299
300	void
301	rdpsnd_register_drivers(char *options)
302	{
303	struct audio_driver **reg;
304
305	/* The order of registrations define the probe-order
306	when opening the device for the first time */
307	reg = &drivers;
308	#if defined(RDPSND_ALSA)
309	*reg = alsa_register(options);
310	reg = &((*reg)->next);
311	#endif
312	#if defined(RDPSND_OSS)
313	*reg = oss_register(options);
314	reg = &((*reg)->next);
315	#endif
316	#if defined(RDPSND_SUN)
317	*reg = sun_register(options);
318	reg = &((*reg)->next);
319	#endif
320	#if defined(RDPSND_SGI)
321	*reg = sgi_register(options);
322	reg = &((*reg)->next);
323	#endif
324	#if defined(RDPSND_LIBAO)
325	*reg = libao_register(options);
326	reg = &((*reg)->next);
327	#endif
328	}
329
330	BOOL
331	rdpsnd_select_driver(char driver, char options)
332	{
333	static struct audio_driver auto_driver;
334	struct audio_driver *pos;
335
336	drivers = NULL;
337	rdpsnd_register_drivers(options);
338
339	if (!driver)
340	{
341	auto_driver.wave_out_open = &rdpsnd_auto_open;
342	current_driver = &auto_driver;
343	return True;
344	}
345
346	pos = drivers;
347	while (pos != NULL)
348	{
349	if (!strcmp(pos->name, driver))
350	{
351	DEBUG(("selected %s\n", pos->name));
352	current_driver = pos;
353	return True;
354	}
355	pos = pos->next;
356	}
357	return False;
358	}
359
360	void
361	rdpsnd_show_help(void)
362	{
363	struct audio_driver *pos;
364
365	rdpsnd_register_drivers(NULL);
366
367	pos = drivers;
368	while (pos != NULL)
369	{
370	fprintf(stderr, " %s:\t%s\n", pos->name, pos->description);
371	pos = pos->next;
372	}
373	}
374
375	inline void
376	rdpsnd_play(void)
377	{
378	current_driver->wave_out_play();
379	}
380
381	void
382	rdpsnd_queue_write(STREAM s, uint16 tick, uint8 index)
383	{
384	struct audio_packet *packet = &packet_queue[queue_hi];
385	unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;
386
387	if (next_hi == queue_lo)
388	{
389	error("No space to queue audio packet\n");
390	return;
391	}
392
393	queue_hi = next_hi;
394
395	packet->s = *s;
396	packet->tick = tick;
397	packet->index = index;
398	packet->s.p += 4;
399
400	/* we steal the data buffer from s, give it a new one */
401	s->data = malloc(s->size);
402
403	if (!g_dsp_busy)
404	current_driver->wave_out_play();
405	}
406
407	inline struct audio_packet *
408	rdpsnd_queue_current_packet(void)
409	{
410	return &packet_queue[queue_lo];
411	}
412
413	inline BOOL
414	rdpsnd_queue_empty(void)
415	{
416	return (queue_lo == queue_hi);
417	}
418
419	inline void
420	rdpsnd_queue_init(void)
421	{
422	queue_lo = queue_hi = 0;
423	}
424
425	inline void
426	rdpsnd_queue_next(void)
427	{
428	free(packet_queue[queue_lo].s.data);
429	queue_lo = (queue_lo + 1) % MAX_QUEUE;
430	}
431
432	inline int
433	rdpsnd_queue_next_tick(void)
434	{
435	if (((queue_lo + 1) % MAX_QUEUE) != queue_hi)
436	{
437	return packet_queue[(queue_lo + 1) % MAX_QUEUE].tick;
438	}
439	else
440	{
441	return (packet_queue[queue_lo].tick + 65535) % 65536;
442	}
443	}