static void rdpsnd_process(STREAM s) { 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 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_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; }
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; default: unimpl("RDPSND packet type %x\n", opcode); break; } }
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 (rdpsnd_negotiated) { error("RDPSND: Extra RDPSND_NEGOTIATE in the middle of a session\n"); /* Do a complete reset of the sound state */ rdpsnd_reset_state(); } if (!current_driver && g_rdpsnd) 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); uint32 flags = TSSNDCAPS_VOLUME; /* if sound is enabled, set snd caps to alive to enable transmision of audio from server */ if (g_rdpsnd) { flags |= TSSNDCAPS_ALIVE; } out_uint32_le(out, flags); /* TSSNDCAPS 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); rdpsnd_negotiated = True; }
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 (rdpsnd_rec_negotiated) { error( "RDPSND: Extra RDPSND_REC_NEGOTIATE in the middle of a session\n"); /* Do a complete reset of the sound state */ rdpsnd_reset_state(); } 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); rdpsnd_rec_negotiated = True; }