rdpsnd.c

Go to the documentation of this file.

/* -*- 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);
}