--- sourceforge.net/trunk/rdesktop/rdpsnd.c 2003/07/01 09:31:25 432 +++ sourceforge.net/trunk/rdesktop/rdpsnd.c 2008/02/08 10:34:53 1430 @@ -1,17 +1,899 @@ +/* -*- c-basic-offset: 8 -*- + rdesktop: A Remote Desktop Protocol client. + Sound Channel Process Functions + Copyright 2006-2007 Pierre Ossman for Cendio AB + Copyright (C) Matthew Chapman 2003-2007 + 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 + #include "rdesktop.h" +#include "rdpsnd.h" +#include "rdpsnd_dsp.h" + +#define RDPSND_CLOSE 1 +#define RDPSND_WRITE 2 +#define RDPSND_SET_VOLUME 3 +#define RDPSND_UNKNOWN4 4 +#define RDPSND_COMPLETION 5 +#define RDPSND_PING 6 +#define RDPSND_NEGOTIATE 7 + +#define RDPSND_REC_NEGOTIATE 39 +#define RDPSND_REC_START 40 +#define RDPSND_REC_STOP 41 +#define RDPSND_REC_DATA 42 +#define RDPSND_REC_SET_VOLUME 43 + +#define RDPSND_FLAG_RECORD 0x00800000 + +#define MAX_FORMATS 10 +#define MAX_QUEUE 50 static VCHANNEL *rdpsnd_channel; +static VCHANNEL *rdpsnddbg_channel; +static struct audio_driver *drivers = NULL; +struct audio_driver *current_driver = NULL; + +static RD_BOOL device_open; +static RD_BOOL rec_device_open; + +static RD_WAVEFORMATEX formats[MAX_FORMATS]; +static unsigned int format_count; +static unsigned int current_format; + +static RD_WAVEFORMATEX rec_formats[MAX_FORMATS]; +static unsigned int rec_format_count; +static unsigned int rec_current_format; + +unsigned int queue_hi, queue_lo, queue_pending; +struct audio_packet packet_queue[MAX_QUEUE]; + +static char record_buffer[8192]; +static uint32 record_buffer_size; + +static uint8 packet_opcode; +static struct stream packet; + +void (*wave_out_play) (void); + +static void rdpsnd_queue_write(STREAM s, uint16 tick, uint8 index); +static void rdpsnd_queue_init(void); +static void rdpsnd_queue_complete_pending(void); +static long rdpsnd_queue_next_completion(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) +{ + channel_send(s, rdpsnd_channel); +} + +static 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); + + DEBUG_SOUND(("RDPSND: -> RDPSND_COMPLETION(tick: %u, index: %u)\n", + (unsigned) tick, (unsigned) packet_index)); +} + +static void +rdpsnd_flush_record(void) +{ + STREAM s; + unsigned int chunk_size; + char *data; + + if (record_buffer_size == 0) + return; + + assert(record_buffer_size <= sizeof(record_buffer)); + + data = record_buffer; + + /* + * Microsoft's RDP server keeps dropping chunks, so we need to + * transmit everything inside one channel fragment or we risk + * making the rdpsnd server go out of sync with the byte stream. + */ + while (record_buffer_size) + { + if (record_buffer_size < 1596) + chunk_size = record_buffer_size; + else + chunk_size = 1596; + + s = rdpsnd_init_packet(RDPSND_REC_DATA, chunk_size); + out_uint8p(s, data, chunk_size); + + s_mark_end(s); + rdpsnd_send(s); + + data = data + chunk_size; + record_buffer_size -= chunk_size; + + DEBUG_SOUND(("RDPSND: -> RDPSND_REC_DATA(length: %u)\n", (unsigned) chunk_size)); + } + + record_buffer_size = 0; +} + +void +rdpsnd_record(const void *data, unsigned int size) +{ + uint32 remain, chunk; + + assert(rec_device_open); + + while (size) + { + remain = sizeof(record_buffer) - record_buffer_size; + + if (size >= remain) + chunk = remain; + else + chunk = size; + + memcpy(record_buffer + record_buffer_size, data, chunk); + +#ifdef B_ENDIAN + if (current_driver->need_byteswap_on_be) + rdpsnd_dsp_swapbytes(record_buffer + record_buffer_size, + chunk, &rec_formats[rec_current_format]); +#endif + + record_buffer_size += chunk; + + data = (const char *) data + chunk; + size -= chunk; + + if (record_buffer_size == sizeof(record_buffer)) + rdpsnd_flush_record(); + } +} + +static RD_BOOL +rdpsnd_auto_select(void) +{ + static RD_BOOL failed = False; + + if (!failed) + { + 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)); + current_driver->wave_out_close(); + return True; + } + current_driver = current_driver->next; + } + + warning("no working audio-driver found\n"); + failed = True; + current_driver = NULL; + } + + return False; +} + +static void +rdpsnd_process_negotiate(STREAM in) +{ + uint16 in_format_count, i; + uint8 pad; + uint16 version; + RD_WAVEFORMATEX *format; + STREAM out; + RD_BOOL device_available = False; + int readcnt; + int discardcnt; + + in_uint8s(in, 14); /* initial bytes not valid from server */ + in_uint16_le(in, in_format_count); + in_uint8(in, pad); + in_uint16_le(in, version); + in_uint8s(in, 1); /* padding */ + + DEBUG_SOUND(("RDPSND: RDPSND_NEGOTIATE(formats: %d, pad: 0x%02x, version: %x)\n", + (int) in_format_count, (unsigned) pad, (unsigned) version)); + + if (!current_driver) + device_available = rdpsnd_auto_select(); + + if (current_driver && !device_available && 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 (current_driver && 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, 0x00800003); /* 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, 0); /* padding */ + out_uint16_le(out, 2); /* version */ + out_uint8(out, 0); /* padding */ + + 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); + + DEBUG_SOUND(("RDPSND: -> RDPSND_NEGOTIATE(formats: %d)\n", (int) format_count)); + + rdpsnd_send(out); +} + +static void +rdpsnd_process_ping(STREAM in) +{ + uint16 tick; + STREAM out; + + in_uint16_le(in, tick); + + DEBUG_SOUND(("RDPSND: RDPSND_PING(tick: 0x%04x)\n", (unsigned) tick)); + + out = rdpsnd_init_packet(RDPSND_PING | 0x2300, 4); + out_uint16_le(out, tick); + out_uint16_le(out, 0); + s_mark_end(out); + rdpsnd_send(out); + + DEBUG_SOUND(("RDPSND: -> (tick: 0x%04x)\n", (unsigned) tick)); +} + +static void +rdpsnd_process_rec_negotiate(STREAM in) +{ + uint16 in_format_count, i; + uint16 version; + RD_WAVEFORMATEX *format; + STREAM out; + RD_BOOL device_available = False; + int readcnt; + int discardcnt; + + in_uint8s(in, 8); /* initial bytes not valid from server */ + in_uint16_le(in, in_format_count); + in_uint16_le(in, version); + + DEBUG_SOUND(("RDPSND: RDPSND_REC_NEGOTIATE(formats: %d, version: %x)\n", + (int) in_format_count, (unsigned) version)); + + if (!current_driver) + device_available = rdpsnd_auto_select(); + + if (current_driver && !device_available && current_driver->wave_in_open + && current_driver->wave_in_open()) + { + current_driver->wave_in_close(); + device_available = True; + } + + rec_format_count = 0; + if (s_check_rem(in, 18 * in_format_count)) + { + for (i = 0; i < in_format_count; i++) + { + format = &rec_formats[rec_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 (current_driver && current_driver->wave_in_format_supported + && current_driver->wave_in_format_supported(format)) + { + rec_format_count++; + if (rec_format_count == MAX_FORMATS) + break; + } + } + } + + out = rdpsnd_init_packet(RDPSND_REC_NEGOTIATE, 12 + 18 * rec_format_count); + out_uint32_le(out, 0x00000000); /* flags */ + out_uint32_le(out, 0xffffffff); /* volume */ + out_uint16_le(out, rec_format_count); + out_uint16_le(out, 1); /* version */ + + for (i = 0; i < rec_format_count; i++) + { + format = &rec_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); + + DEBUG_SOUND(("RDPSND: -> RDPSND_REC_NEGOTIATE(formats: %d)\n", (int) rec_format_count)); + + rdpsnd_send(out); +} + +static void +rdpsnd_process_packet(uint8 opcode, STREAM s) +{ + uint16 vol_left, vol_right; + static uint16 tick, format; + static uint8 packet_index; + + switch (opcode) + { + case RDPSND_WRITE: + in_uint16_le(s, tick); + in_uint16_le(s, format); + in_uint8(s, packet_index); + in_uint8s(s, 3); + DEBUG_SOUND(("RDPSND: RDPSND_WRITE(tick: %u, format: %u, index: %u, data: %u bytes)\n", (unsigned) tick, (unsigned) format, (unsigned) packet_index, (unsigned) s->size - 8)); + + if (format >= MAX_FORMATS) + { + error("RDPSND: Invalid format index\n"); + break; + } + + if (!device_open || (format != current_format)) + { + /* + * If we haven't selected a device by now, then either + * we've failed to find a working device, or the server + * is sending bogus RDPSND_WRITE. + */ + if (!current_driver) + { + rdpsnd_send_completion(tick, packet_index); + break; + } + if (!device_open && !current_driver->wave_out_open()) + { + rdpsnd_send_completion(tick, packet_index); + break; + } + if (!current_driver->wave_out_set_format(&formats[format])) + { + rdpsnd_send_completion(tick, packet_index); + current_driver->wave_out_close(); + device_open = False; + break; + } + device_open = True; + current_format = format; + } + + rdpsnd_queue_write(rdpsnd_dsp_process + (s->p, s->end - s->p, current_driver, + &formats[current_format]), tick, packet_index); + return; + break; + case RDPSND_CLOSE: + DEBUG_SOUND(("RDPSND: RDPSND_CLOSE()\n")); + if (device_open) + current_driver->wave_out_close(); + device_open = False; + break; + case RDPSND_NEGOTIATE: + rdpsnd_process_negotiate(s); + break; + case RDPSND_PING: + rdpsnd_process_ping(s); + break; + case RDPSND_SET_VOLUME: + in_uint16_le(s, vol_left); + in_uint16_le(s, vol_right); + DEBUG_SOUND(("RDPSND: RDPSND_VOLUME(left: 0x%04x (%u %%), right: 0x%04x (%u %%))\n", (unsigned) vol_left, (unsigned) vol_left / 655, (unsigned) vol_right, (unsigned) vol_right / 655)); + if (device_open) + current_driver->wave_out_volume(vol_left, vol_right); + break; + case RDPSND_REC_NEGOTIATE: + rdpsnd_process_rec_negotiate(s); + break; + case RDPSND_REC_START: + in_uint16_le(s, format); + DEBUG_SOUND(("RDPSND: RDPSND_REC_START(format: %u)\n", (unsigned) format)); + + if (format >= MAX_FORMATS) + { + error("RDPSND: Invalid format index\n"); + break; + } + + if (rec_device_open) + { + error("RDPSND: Multiple RDPSND_REC_START\n"); + break; + } + + if (!current_driver->wave_in_open()) + break; + + if (!current_driver->wave_in_set_format(&rec_formats[format])) + { + error("RDPSND: Device not accepting format\n"); + current_driver->wave_in_close(); + break; + } + rec_current_format = format; + rec_device_open = True; + break; + case RDPSND_REC_STOP: + DEBUG_SOUND(("RDPSND: RDPSND_REC_STOP()\n")); + rdpsnd_flush_record(); + if (rec_device_open) + current_driver->wave_in_close(); + rec_device_open = False; + break; + case RDPSND_REC_SET_VOLUME: + in_uint16_le(s, vol_left); + in_uint16_le(s, vol_right); + DEBUG_SOUND(("RDPSND: RDPSND_REC_VOLUME(left: 0x%04x (%u %%), right: 0x%04x (%u %%))\n", (unsigned) vol_left, (unsigned) vol_left / 655, (unsigned) vol_right, (unsigned) vol_right / 655)); + if (rec_device_open) + current_driver->wave_in_volume(vol_left, vol_right); + break; + default: + unimpl("RDPSND packet type %x\n", opcode); + break; + } +} static void rdpsnd_process(STREAM s) { - printf("rdpsnd_process\n"); - hexdump(s->p, s->end-s->p); + uint16 len; + + while (!s_check_end(s)) + { + /* New packet */ + if (packet.size == 0) + { + if ((s->end - s->p) < 4) + { + error("RDPSND: Split at packet header. Things will go south from here...\n"); + return; + } + in_uint8(s, packet_opcode); + in_uint8s(s, 1); /* Padding */ + in_uint16_le(s, len); + + DEBUG_SOUND(("RDPSND: == Opcode %x Length: %d ==\n", + (int) packet_opcode, (int) len)); + + packet.p = packet.data; + packet.end = packet.data + len; + packet.size = len; + } + else + { + len = MIN(s->end - s->p, packet.end - packet.p); + + /* Microsoft's server is so broken it's not even funny... */ + if (packet_opcode == RDPSND_WRITE) + { + if ((packet.p - packet.data) < 12) + len = MIN(len, 12 - (packet.p - packet.data)); + else if ((packet.p - packet.data) == 12) + { + DEBUG_SOUND(("RDPSND: Eating 4 bytes of %d bytes...\n", + len)); + in_uint8s(s, 4); + len -= 4; + } + } + + in_uint8a(s, packet.p, len); + packet.p += len; + } + + /* Packet fully assembled */ + if (packet.p == packet.end) + { + packet.p = packet.data; + rdpsnd_process_packet(packet_opcode, &packet); + packet.size = 0; + } + } +} + +static RD_BOOL +rdpsnddbg_line_handler(const char *line, void *data) +{ +#ifdef WITH_DEBUG_SOUND + fprintf(stderr, "SNDDBG: %s\n", line); +#endif + return True; +} + +static void +rdpsnddbg_process(STREAM s) +{ + unsigned int pkglen; + static char *rest = NULL; + char *buf; + + pkglen = s->end - s->p; + /* str_handle_lines requires null terminated strings */ + buf = (char *) xmalloc(pkglen + 1); + STRNCPY(buf, (char *) s->p, pkglen + 1); + + str_handle_lines(buf, &rest, rdpsnddbg_line_handler, NULL); + + xfree(buf); +} + +static 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); + assert(*reg); + reg = &((*reg)->next); +#endif +#if defined(RDPSND_SUN) + *reg = sun_register(options); + assert(*reg); + reg = &((*reg)->next); +#endif +#if defined(RDPSND_OSS) + *reg = oss_register(options); + assert(*reg); + reg = &((*reg)->next); +#endif +#if defined(RDPSND_SGI) + *reg = sgi_register(options); + assert(*reg); + reg = &((*reg)->next); +#endif +#if defined(RDPSND_LIBAO) + *reg = libao_register(options); + assert(*reg); + reg = &((*reg)->next); +#endif + *reg = NULL; +} + +RD_BOOL +rdpsnd_init(char *optarg) +{ + struct audio_driver *pos; + char *driver = NULL, *options = NULL; + + drivers = NULL; + + packet.data = (uint8 *) xmalloc(65536); + packet.p = packet.end = packet.data; + packet.size = 0; + + rdpsnd_channel = + channel_register("rdpsnd", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP, + rdpsnd_process); + + rdpsnddbg_channel = + channel_register("snddbg", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP, + rdpsnddbg_process); + + if ((rdpsnd_channel == NULL) || (rdpsnddbg_channel == NULL)) + { + error("channel_register\n"); + return False; + } + + rdpsnd_queue_init(); + + if (optarg != NULL && strlen(optarg) > 0) + { + driver = options = optarg; + + while (*options != '\0' && *options != ':') + options++; + + if (*options == ':') + { + *options = '\0'; + options++; + } + + if (*options == '\0') + options = NULL; + } + + rdpsnd_register_drivers(options); + + if (!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; + } +} + +void +rdpsnd_add_fds(int *n, fd_set * rfds, fd_set * wfds, struct timeval *tv) +{ + long next_pending; + + if (device_open || rec_device_open) + current_driver->add_fds(n, rfds, wfds, tv); + + next_pending = rdpsnd_queue_next_completion(); + if (next_pending >= 0) + { + long cur_timeout; + + cur_timeout = tv->tv_sec * 1000000 + tv->tv_usec; + if (cur_timeout > next_pending) + { + tv->tv_sec = next_pending / 1000000; + tv->tv_usec = next_pending % 1000000; + } + } +} + +void +rdpsnd_check_fds(fd_set * rfds, fd_set * wfds) +{ + rdpsnd_queue_complete_pending(); + + if (device_open || rec_device_open) + current_driver->check_fds(rfds, wfds); } -BOOL -rdpsnd_init(void) +static void +rdpsnd_queue_write(STREAM s, uint16 tick, uint8 index) { - rdpsnd_channel = channel_register("rdpsnd", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP, rdpsnd_process); - return (rdpsnd_channel != NULL); + struct audio_packet *packet = &packet_queue[queue_hi]; + unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE; + + if (next_hi == queue_pending) + { + error("No space to queue audio packet\n"); + return; + } + + queue_hi = next_hi; + + packet->s = *s; + packet->tick = tick; + packet->index = index; + + gettimeofday(&packet->arrive_tv, NULL); +} + +struct audio_packet * +rdpsnd_queue_current_packet(void) +{ + return &packet_queue[queue_lo]; +} + +RD_BOOL +rdpsnd_queue_empty(void) +{ + return (queue_lo == queue_hi); +} + +static void +rdpsnd_queue_init(void) +{ + queue_pending = queue_lo = queue_hi = 0; +} + +void +rdpsnd_queue_next(unsigned long completed_in_us) +{ + struct audio_packet *packet; + + assert(!rdpsnd_queue_empty()); + + packet = &packet_queue[queue_lo]; + + gettimeofday(&packet->completion_tv, NULL); + + packet->completion_tv.tv_usec += completed_in_us; + packet->completion_tv.tv_sec += packet->completion_tv.tv_usec / 1000000; + packet->completion_tv.tv_usec %= 1000000; + + queue_lo = (queue_lo + 1) % MAX_QUEUE; + + rdpsnd_queue_complete_pending(); +} + +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; + } +} + +static void +rdpsnd_queue_complete_pending(void) +{ + struct timeval now; + long elapsed; + struct audio_packet *packet; + + gettimeofday(&now, NULL); + + while (queue_pending != queue_lo) + { + packet = &packet_queue[queue_pending]; + + if (now.tv_sec < packet->completion_tv.tv_sec) + break; + + if ((now.tv_sec == packet->completion_tv.tv_sec) && + (now.tv_usec < packet->completion_tv.tv_usec)) + break; + + elapsed = (packet->completion_tv.tv_sec - packet->arrive_tv.tv_sec) * 1000000 + + (packet->completion_tv.tv_usec - packet->arrive_tv.tv_usec); + elapsed /= 1000; + + xfree(packet->s.data); + rdpsnd_send_completion((packet->tick + elapsed) % 65536, packet->index); + queue_pending = (queue_pending + 1) % MAX_QUEUE; + } +} + +static long +rdpsnd_queue_next_completion(void) +{ + struct audio_packet *packet; + long remaining; + struct timeval now; + + if (queue_pending == queue_lo) + return -1; + + gettimeofday(&now, NULL); + + packet = &packet_queue[queue_pending]; + + remaining = (packet->completion_tv.tv_sec - now.tv_sec) * 1000000 + + (packet->completion_tv.tv_usec - now.tv_usec); + + if (remaining < 0) + return 0; + + return remaining; }