--- /dev/null
+/* -*- 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.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "rdesktop.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
+
+static STREAM
+rdpsnd_init_packet(RDPCLIENT * This, uint16 type, uint16 size)
+{
+ STREAM s;
+
+ s = channel_init(This, This->rdpsnd.channel, size + 4);
+ out_uint16_le(s, type);
+ out_uint16_le(s, size);
+ return s;
+}
+
+static void
+rdpsnd_send(RDPCLIENT * This, STREAM s)
+{
+#ifdef RDPSND_DEBUG
+ printf("RDPSND send:\n");
+ hexdump(s->channel_hdr + 8, s->end - s->channel_hdr - 8);
+#endif
+
+ channel_send(This, s, This->rdpsnd.channel);
+}
+
+void
+rdpsnd_send_completion(RDPCLIENT * This, uint16 tick, uint8 packet_index)
+{
+ STREAM s;
+
+ s = rdpsnd_init_packet(This, RDPSND_COMPLETION, 4);
+ out_uint16_le(s, tick + 50);
+ out_uint8(s, packet_index);
+ out_uint8(s, 0);
+ s_mark_end(s);
+ rdpsnd_send(This, s);
+}
+
+static void
+rdpsnd_process_negotiate(RDPCLIENT * This, 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 (wave_out_open())
+ {
+ wave_out_close();
+ device_available = True;
+ }
+
+ This->rdpsnd.format_count = 0;
+ if (s_check_rem(in, 18 * in_format_count))
+ {
+ for (i = 0; i < in_format_count; i++)
+ {
+ format = &This->rdpsnd.formats[This->rdpsnd.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 && wave_out_format_supported(format))
+ {
+ This->rdpsnd.format_count++;
+ if (This->rdpsnd.format_count == MAX_FORMATS)
+ break;
+ }
+ }
+ }
+
+ out = rdpsnd_init_packet(This, RDPSND_NEGOTIATE | 0x200, 20 + 18 * This->rdpsnd.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, This->rdpsnd.format_count);
+ out_uint8(out, 0x95); /* pad? */
+ out_uint16_le(out, 2); /* status */
+ out_uint8(out, 0x77); /* pad? */
+
+ for (i = 0; i < This->rdpsnd.format_count; i++)
+ {
+ format = &This->rdpsnd.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(This, out);
+}
+
+static void
+rdpsnd_process_servertick(RDPCLIENT * This, 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(This, RDPSND_SERVERTICK | 0x2300, 4);
+ out_uint16_le(out, tick1);
+ out_uint16_le(out, tick2);
+ s_mark_end(out);
+ rdpsnd_send(This, out);
+}
+
+static void
+rdpsnd_process(RDPCLIENT * This, 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 (!This->rdpsnd.device_open || (format != This->rdpsnd.current_format))
+ {
+ if (!This->rdpsnd.device_open && !wave_out_open())
+ {
+ rdpsnd_send_completion(This, tick, packet_index);
+ return;
+ }
+ if (!wave_out_set_format(&This->rdpsnd.formats[format]))
+ {
+ rdpsnd_send_completion(This, tick, packet_index);
+ wave_out_close();
+ This->rdpsnd.device_open = False;
+ return;
+ }
+ This->rdpsnd.device_open = True;
+ This->rdpsnd.current_format = format;
+ }
+
+ 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:
+ wave_out_close();
+ This->rdpsnd.device_open = False;
+ break;
+ case RDPSND_NEGOTIATE:
+ rdpsnd_process_negotiate(This, s);
+ break;
+ case RDPSND_SERVERTICK:
+ rdpsnd_process_servertick(This, s);
+ break;
+ case RDPSND_SET_VOLUME:
+ in_uint32(s, volume);
+ if (This->rdpsnd.device_open)
+ {
+ wave_out_volume((volume & 0xffff), (volume & 0xffff0000) >> 16);
+ }
+ break;
+ default:
+ unimpl("RDPSND packet type %d\n", type);
+ break;
+ }
+}
+
+BOOL
+rdpsnd_init(RDPCLIENT * This)
+{
+ This->rdpsnd.channel =
+ channel_register(This, "rdpsnd", CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP,
+ rdpsnd_process);
+ return (This->rdpsnd.channel != NULL);
+}
projects / reactos.git / blobdiff