--- sourceforge.net/trunk/rdesktop/rdpsnd.c 2006/09/17 14:41:16 1258 +++ sourceforge.net/trunk/rdesktop/rdpsnd.c 2006/12/06 13:55:34 1343 @@ -1,6 +1,7 @@ /* -*- c-basic-offset: 8 -*- rdesktop: A Remote Desktop Protocol client. Sound Channel Process Functions + Copyright 2006 Pierre Ossman for Cendio AB Copyright (C) Matthew Chapman 2003 Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003 @@ -19,6 +20,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#include + #include "rdesktop.h" #include "rdpsnd.h" #include "rdpsnd_dsp.h" @@ -28,7 +31,7 @@ #define RDPSND_SET_VOLUME 3 #define RDPSND_UNKNOWN4 4 #define RDPSND_COMPLETION 5 -#define RDPSND_SERVERTICK 6 +#define RDPSND_PING 6 #define RDPSND_NEGOTIATE 7 #define MAX_FORMATS 10 @@ -45,11 +48,19 @@ static WAVEFORMATEX formats[MAX_FORMATS]; static unsigned int format_count; static unsigned int current_format; -unsigned int queue_hi, queue_lo; +unsigned int queue_hi, queue_lo, queue_pending; struct audio_packet packet_queue[MAX_QUEUE]; +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) { @@ -64,15 +75,10 @@ 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 +static void rdpsnd_send_completion(uint16 tick, uint8 packet_index) { STREAM s; @@ -83,21 +89,31 @@ 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_process_negotiate(STREAM in) { - unsigned int in_format_count, i; + uint16 in_format_count, i; + uint8 pad; + uint16 version; WAVEFORMATEX *format; STREAM out; BOOL device_available = False; int readcnt; int discardcnt; - in_uint8s(in, 14); /* flags, volume, pitch, UDP port */ + in_uint8s(in, 14); /* initial bytes not valid from server */ in_uint16_le(in, in_format_count); - in_uint8s(in, 4); /* pad, status, pad */ + in_uint8(in, pad); + in_uint16_le(in, version); + in_uint8s(in, 1); /* padding */ + + DEBUG_SOUND(("RDPSND: RDPSND_NEGOTIATE(formats: %d, pad1: 0x%02x, version: %x)\n", + (int) in_format_count, (unsigned) pad1, (unsigned) version)); if (current_driver->wave_out_open()) { @@ -148,9 +164,9 @@ 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? */ + out_uint8(out, 0); /* padding */ + out_uint16_le(out, 2); /* version */ + out_uint8(out, 0); /* padding */ for (i = 0; i < format_count; i++) { @@ -165,140 +181,189 @@ } s_mark_end(out); + + DEBUG_SOUND(("RDPSND: -> RDPSND_NEGOTIATE(formats: %d)\n", (int) format_count)); + rdpsnd_send(out); } static void -rdpsnd_process_servertick(STREAM in) +rdpsnd_process_ping(STREAM in) { - uint16 tick1, tick2; + uint16 tick; 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); + 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(STREAM s) +rdpsnd_process_packet(uint8 opcode, STREAM s) { - uint8 type; - uint16 datalen; - uint32 volume; + uint16 vol_left, vol_right; 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) + switch (opcode) { - if (format >= MAX_FORMATS) - { - error("RDPSND: Invalid format index\n"); - return; - } + 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 (!device_open || (format != current_format)) - { - if (!device_open && !current_driver->wave_out_open()) + if (format >= MAX_FORMATS) { - rdpsnd_send_completion(tick, packet_index); - return; + error("RDPSND: Invalid format index\n"); + break; } - if (!current_driver->wave_out_set_format(&formats[format])) + + if (!device_open || (format != current_format)) { - rdpsnd_send_completion(tick, packet_index); - current_driver->wave_out_close(); - device_open = False; - return; + 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; } - 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; + 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")); current_driver->wave_out_close(); device_open = False; break; case RDPSND_NEGOTIATE: rdpsnd_process_negotiate(s); break; - case RDPSND_SERVERTICK: - rdpsnd_process_servertick(s); + case RDPSND_PING: + rdpsnd_process_ping(s); break; case RDPSND_SET_VOLUME: - in_uint32(s, 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((volume & 0xffff), - (volume & 0xffff0000) >> 16); - } + current_driver->wave_out_volume(vol_left, vol_right); break; default: - unimpl("RDPSND packet type %d\n", type); + unimpl("RDPSND packet type %x\n", opcode); break; } } -BOOL -rdpsnd_init(void) +static void +rdpsnd_process(STREAM s) { - rdpsnd_channel = - channel_register("rdpsnd", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP, - rdpsnd_process); + 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; + } + } - return (rdpsnd_channel != NULL); + 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; + } + } } -BOOL +static BOOL rdpsnd_auto_open(void) { - current_driver = drivers; - while (current_driver != NULL) + static BOOL failed = False; + + if (!failed) { - DEBUG(("trying %s...\n", current_driver->name)); - if (current_driver->wave_out_open()) + struct audio_driver *auto_driver = current_driver; + + current_driver = drivers; + while (current_driver != NULL) { - DEBUG(("selected %s\n", current_driver->name)); - return True; + 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; } - g_dsp_fd = 0; - current_driver = current_driver->next; - } - warning("no working audio-driver found\n"); + warning("no working audio-driver found\n"); + failed = True; + current_driver = auto_driver; + } return False; } -void +static void rdpsnd_register_drivers(char *options) { struct audio_driver **reg; @@ -308,33 +373,74 @@ reg = &drivers; #if defined(RDPSND_ALSA) *reg = alsa_register(options); - reg = &((*reg)->next); -#endif -#if defined(RDPSND_OSS) - *reg = oss_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; } BOOL -rdpsnd_select_driver(char *driver, char *options) +rdpsnd_init(char *optarg) { static struct audio_driver auto_driver; struct audio_driver *pos; + char *driver = NULL, *options = NULL; drivers = NULL; + + packet.data = 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); + + if (rdpsnd_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) @@ -373,19 +479,53 @@ } } -inline void +void rdpsnd_play(void) { current_driver->wave_out_play(); } void +rdpsnd_add_fds(int *n, fd_set * rfds, fd_set * wfds, struct timeval *tv) +{ + long next_pending; + + if (g_dsp_busy) + { + FD_SET(g_dsp_fd, wfds); + *n = (g_dsp_fd > *n) ? g_dsp_fd : *n; + } + + 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 (g_dsp_busy && FD_ISSET(g_dsp_fd, wfds)) + rdpsnd_play(); +} + +static 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) + if (next_hi == queue_pending) { error("No space to queue audio packet\n"); return; @@ -394,48 +534,54 @@ queue_hi = next_hi; packet->s = *s; - packet->s.data = - rdpsnd_dsp_process(s->data, s->size, current_driver, &formats[current_format]); - packet->s.p = packet->s.data + 4; - packet->s.end = packet->s.data + s->size; packet->tick = tick; packet->index = index; -#if 0 /* Handled by DSP */ - /* we steal the data buffer from s, give it a new one */ - s->data = xmalloc(s->size); -#endif + gettimeofday(&packet->arrive_tv, NULL); if (!g_dsp_busy) current_driver->wave_out_play(); } -inline struct audio_packet * +struct audio_packet * rdpsnd_queue_current_packet(void) { return &packet_queue[queue_lo]; } -inline BOOL +BOOL rdpsnd_queue_empty(void) { return (queue_lo == queue_hi); } -inline void +static void rdpsnd_queue_init(void) { - queue_lo = queue_hi = 0; + queue_pending = queue_lo = queue_hi = 0; } -inline void -rdpsnd_queue_next(void) +void +rdpsnd_queue_next(unsigned long completed_in_us) { - xfree(packet_queue[queue_lo].s.data); + 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(); } -inline int +int rdpsnd_queue_next_tick(void) { if (((queue_lo + 1) % MAX_QUEUE) != queue_hi) @@ -447,3 +593,56 @@ 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; +}