mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:FreeRDP/FreeRDP into winpr

This commit is contained in:
Marc-André Moreau 2012-05-25 18:45:12 -04:00
parent 337bcf7605 519f71c828
commit ae6f331570
29 changed files with 1260 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
channels/rdpsnd/alsa/rdpsnd_alsa.c
View File

@ -138,6 +138,7 @@ static void rdpsnd_alsa_set_format(rdpsndDevicePlugin* device, rdpsndFormat* for
}
break;
case 2: /* MS ADPCM */
case 0x11: /* IMA ADPCM */
alsa->format = SND_PCM_FORMAT_S16_LE;
alsa->bytes_per_channel = 2;
@ -212,6 +213,7 @@ static boolean rdpsnd_alsa_format_supported(rdpsndDevicePlugin* device, rdpsndFo
}
break;
case 2: /* MS ADPCM */
case 0x11: /* IMA ADPCM */
if (format->nSamplesPerSec <= 48000 &&
format->wBitsPerSample == 4 &&
@ -243,7 +245,14 @@ static void rdpsnd_alsa_play(rdpsndDevicePlugin* device, uint8* data, int size)
if (alsa->out_handle == 0)
return;
if (alsa->wformat == 0x11)
if (alsa->wformat == 2)
{
alsa->dsp_context->decode_ms_adpcm(alsa->dsp_context,
data, size, alsa->source_channels, alsa->block_size);
size = alsa->dsp_context->adpcm_size;
src = alsa->dsp_context->adpcm_buffer;
}
else if (alsa->wformat == 0x11)
{
alsa->dsp_context->decode_ima_adpcm(alsa->dsp_context,
data, size, alsa->source_channels, alsa->block_size);

11
channels/rdpsnd/pulse/rdpsnd_pulse.c
View File

@ -212,6 +212,7 @@ static void rdpsnd_pulse_set_format_spec(rdpsndPulsePlugin* pulse, rdpsndFormat*
sample_spec.format = PA_SAMPLE_ULAW;
break;
case 2: /* MS ADPCM */
case 0x11: /* IMA ADPCM */
sample_spec.format = PA_SAMPLE_S16LE;
break;
@ -364,6 +365,7 @@ static boolean rdpsnd_pulse_format_supported(rdpsndDevicePlugin* device, rdpsndF
}
break;
case 2: /* MS ADPCM */
case 0x11: /* IMA ADPCM */
if ((format->nSamplesPerSec <= PA_RATE_MAX) &&
(format->wBitsPerSample == 4) &&
@ -405,7 +407,14 @@ static void rdpsnd_pulse_play(rdpsndDevicePlugin* device, uint8* data, int size)
if (!pulse->stream)
return;
if (pulse->format == 0x11)
if (pulse->format == 2)
{
pulse->dsp_context->decode_ms_adpcm(pulse->dsp_context,
data, size, pulse->sample_spec.channels, pulse->block_size);
size = pulse->dsp_context->adpcm_size;
src = pulse->dsp_context->adpcm_buffer;
}
else if (pulse->format == 0x11)
{
pulse->dsp_context->decode_ima_adpcm(pulse->dsp_context,
data, size, pulse->sample_spec.channels, pulse->block_size);

21
channels/rdpsnd/rdpsnd_main.c
View File

@ -35,27 +35,6 @@
#include "rdpsnd_main.h"
#define SNDC_CLOSE 1
#define SNDC_WAVE 2
#define SNDC_SETVOLUME 3
#define SNDC_SETPITCH 4
#define SNDC_WAVECONFIRM 5
#define SNDC_TRAINING 6
#define SNDC_FORMATS 7
#define SNDC_CRYPTKEY 8
#define SNDC_WAVEENCRYPT 9
#define SNDC_UDPWAVE 10
#define SNDC_UDPWAVELAST 11
#define SNDC_QUALITYMODE 12
#define TSSNDCAPS_ALIVE 1
#define TSSNDCAPS_VOLUME 2
#define TSSNDCAPS_PITCH 4
#define DYNAMIC_QUALITY 0x0000
#define MEDIUM_QUALITY 0x0001
#define HIGH_QUALITY 0x0002
struct rdpsnd_plugin
{
rdpSvcPlugin plugin;

14
channels/rdpsnd/rdpsnd_main.h
View File

@ -20,19 +20,9 @@
#ifndef __RDPSND_MAIN_H
#define __RDPSND_MAIN_H
typedef struct rdpsnd_plugin rdpsndPlugin;
#include <freerdp/channels/rdpsnd.h>
typedef struct rdpsnd_format rdpsndFormat;
struct rdpsnd_format
{
uint16 wFormatTag;
uint16 nChannels;
uint32 nSamplesPerSec;
uint16 nBlockAlign;
uint16 wBitsPerSample;
uint16 cbSize;
uint8* data;
};
typedef struct rdpsnd_plugin rdpsndPlugin;
typedef struct rdpsnd_device_plugin rdpsndDevicePlugin;

2
client/X11/xf_graphics.c
View File

@ -43,7 +43,7 @@ void xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
if (bitmap->data != NULL)
{
data = freerdp_image_convert(bitmap->data, NULL,
bitmap->width, bitmap->height, bitmap->bpp, xfi->bpp, xfi->clrconv);
bitmap->width, bitmap->height, xfi->srcBpp, xfi->bpp, xfi->clrconv);
if (bitmap->ephemeral != true)
{

8
client/X11/xfreerdp.1.xml
View File

@ -137,6 +137,14 @@
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-K</term>
<listitem>
<para>
Do not interfere with window manager bindings. Normally, xfreerdp captures all keystrokes while its window is focused.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>-n <replaceable class="parameter">hostname</replaceable></term>
<listitem>

1
include/CMakeLists.txt
View File

@ -30,6 +30,7 @@ install(DIRECTORY freerdp/plugins DESTINATION include/freerdp FILES_MATCHING PAT
install(DIRECTORY freerdp/locale DESTINATION include/freerdp FILES_MATCHING PATTERN "*.h")
install(DIRECTORY freerdp/crypto DESTINATION include/freerdp FILES_MATCHING PATTERN "*.h")
install(DIRECTORY freerdp/auth DESTINATION include/freerdp FILES_MATCHING PATTERN "*.h")
install(DIRECTORY freerdp/server DESTINATION include/freerdp FILES_MATCHING PATTERN "*.h")
file(GLOB HEADERS "winpr/*.h")
install_files(/include/winpr FILES ${HEADERS})

59
include/freerdp/channels/rdpsnd.h Normal file
View File

@ -0,0 +1,59 @@
/**
* FreeRDP: A Remote Desktop Protocol client.
* Audio Virtual Channel Types
*
* Copyright 2012 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __FREERDP_RDPSND_H
#define __FREERDP_RDPSND_H
#include <freerdp/api.h>
#include <freerdp/types.h>
typedef struct rdpsnd_format rdpsndFormat;
struct rdpsnd_format
{
uint16 wFormatTag;
uint16 nChannels;
uint32 nSamplesPerSec;
uint16 nBlockAlign;
uint16 wBitsPerSample;
uint16 cbSize;
uint8* data;
};
#define SNDC_CLOSE 1
#define SNDC_WAVE 2
#define SNDC_SETVOLUME 3
#define SNDC_SETPITCH 4
#define SNDC_WAVECONFIRM 5
#define SNDC_TRAINING 6
#define SNDC_FORMATS 7
#define SNDC_CRYPTKEY 8
#define SNDC_WAVEENCRYPT 9
#define SNDC_UDPWAVE 10
#define SNDC_UDPWAVELAST 11
#define SNDC_QUALITYMODE 12
#define TSSNDCAPS_ALIVE 1
#define TSSNDCAPS_VOLUME 2
#define TSSNDCAPS_PITCH 4
#define DYNAMIC_QUALITY 0x0000
#define MEDIUM_QUALITY 0x0001
#define HIGH_QUALITY 0x0002
#endif

2
include/freerdp/listener.h
View File

@ -32,6 +32,7 @@ extern "C" {
#endif
typedef boolean (*psListenerOpen)(freerdp_listener* instance, const char* bind_address, uint16 port);
typedef boolean (*psListenerOpenLocal)(freerdp_listener* instance, const char* path);
typedef boolean (*psListenerGetFileDescriptor)(freerdp_listener* instance, void** rfds, int* rcount);
typedef boolean (*psListenerCheckFileDescriptor)(freerdp_listener* instance);
typedef void (*psListenerClose)(freerdp_listener* instance);
@ -47,6 +48,7 @@ struct rdp_freerdp_listener
void* param4;
psListenerOpen Open;
psListenerOpenLocal OpenLocal;
psListenerGetFileDescriptor GetFileDescriptor;
psListenerCheckFileDescriptor CheckFileDescriptor;
psListenerClose Close;

1
include/freerdp/peer.h
View File

@ -69,6 +69,7 @@ struct rdp_freerdp_peer
psPeerReceiveChannelData ReceiveChannelData;
uint32 ack_frame_id;
boolean local;
};
FREERDP_API void freerdp_peer_context_new(freerdp_peer* client);

92
include/freerdp/server/rdpsnd.h Normal file
View File

@ -0,0 +1,92 @@
/**
* FreeRDP: A Remote Desktop Protocol client.
* Server Audio Virtual Channel
*
* Copyright 2012 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __SERVER_RDPSND_H
#define __SERVER_RDPSND_H
#include <freerdp/channels/wtsvc.h>
#include <freerdp/channels/rdpsnd.h>
typedef struct _rdpsnd_server_context rdpsnd_server_context;
typedef boolean (*psRdpsndServerInitialize)(rdpsnd_server_context* context);
typedef void (*psRdpsndServerSelectFormat)(rdpsnd_server_context* context, int client_format_index);
typedef boolean (*psRdpsndServerSendSamples)(rdpsnd_server_context* context, const void* buf, int nframes);
typedef boolean (*psRdpsndServerClose)(rdpsnd_server_context* context);
typedef void (*psRdpsndServerActivated)(rdpsnd_server_context* context);
struct _rdpsnd_server_context
{
WTSVirtualChannelManager* vcm;
/* Server self-defined pointer. */
void* data;
/* Server supported formats. Set by server. */
const rdpsndFormat* server_formats;
int num_server_formats;
/* Server source PCM audio format. Set by server. */
rdpsndFormat src_format;
/* Client supported formats. */
rdpsndFormat* client_formats;
int num_client_formats;
int selected_client_format;
/* Last sent audio block number. */
int block_no;
/*** APIs called by the server. ***/
/**
* Initialize the channel. The caller should check the return value to see
* whether the initialization succeed. If not, the "Activated" callback
* will not be called and the server must not call any API on this context.
*/
psRdpsndServerInitialize Initialize;
/**
* Choose the audio format to be sent. The index argument is an index into
* the client_formats array and must be smaller than num_client_formats.
*/
psRdpsndServerSelectFormat SelectFormat;
/**
* Send audio samples. Actually bytes in the buffer must be:
* nframes * src_format.nBitsPerSample * src_format.nChannels / 8
*/
psRdpsndServerSendSamples SendSamples;
/**
* Close the audio stream.
*/
psRdpsndServerClose Close;
/*** Callbacks registered by the server. ***/
/**
* The channel has been activated. The server maybe choose audio format and
* start audio stream from this point. Note that this callback is called
* from a different thread context so the server must be careful of thread
* synchronization.
*/
psRdpsndServerActivated Activated;
};
FREERDP_API rdpsnd_server_context* rdpsnd_server_context_new(WTSVirtualChannelManager* vcm);
FREERDP_API void rdpsnd_server_context_free(rdpsnd_server_context* context);
#endif

3
include/freerdp/settings.h
View File

@ -292,7 +292,8 @@ struct rdp_settings
ALIGN64 char* tsg_hostname; /* 65 */
ALIGN64 char* tsg_username; /* 66 */
ALIGN64 char* tsg_password; /* 67 */
ALIGN64 uint64 paddingC[80 - 68]; /* 68 */
ALIGN64 boolean local; /* 68 */
ALIGN64 uint64 paddingC[80 - 69]; /* 69 */
/* User Interface Parameters */
ALIGN64 boolean sw_gdi; /* 80 */

23
include/freerdp/utils/dsp.h
View File

@ -22,12 +22,22 @@
#include <freerdp/api.h>
struct _ADPCM
union _ADPCM
{
sint16 last_sample[2];
sint16 last_step[2];
struct
{
sint16 last_sample[2];
sint16 last_step[2];
} ima;
struct
{
uint8 predictor[2];
sint32 delta[2];
sint32 sample1[2];
sint32 sample2[2];
} ms;
};
typedef struct _ADPCM ADPCM;
typedef union _ADPCM ADPCM;
typedef struct _FREERDP_DSP_CONTEXT FREERDP_DSP_CONTEXT;
struct _FREERDP_DSP_CONTEXT
@ -52,6 +62,11 @@ struct _FREERDP_DSP_CONTEXT
const uint8* src, int size, int channels, int block_size);
void (*encode_ima_adpcm)(FREERDP_DSP_CONTEXT* context,
const uint8* src, int size, int channels, int block_size);
void (*decode_ms_adpcm)(FREERDP_DSP_CONTEXT* context,
const uint8* src, int size, int channels, int block_size);
void (*encode_ms_adpcm)(FREERDP_DSP_CONTEXT* context,
const uint8* src, int size, int channels, int block_size);
};
FREERDP_API FREERDP_DSP_CONTEXT* freerdp_dsp_context_new(void);

28
include/freerdp/utils/uds.h Normal file
View File

@ -0,0 +1,28 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* Unix Domain Socket Utils
*
* Copyright 2012 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_UDS_UTILS_H
#define FREERDP_UDS_UTILS_H
#include <freerdp/api.h>
#include <freerdp/types.h>
FREERDP_API int freerdp_uds_connect(const char* path);
#endif /* FREERDP_UDS_UTILS_H */

6
libfreerdp-codec/color.c
View File

@ -821,7 +821,7 @@ uint8* freerdp_icon_convert(uint8* srcData, uint8* dstData, uint8* mask, int wid
for (bit = 0; bit < 8; bit++)
if ((bmask & (0x80 >> bit)) == 0)
*(icon + (height - y) * width + x + bit) |= 0xFF000000;
*(icon + (height - y - 1) * width + x + bit) |= 0xFF000000;
}
if ((width % 8) != 0)
@ -830,7 +830,7 @@ uint8* freerdp_icon_convert(uint8* srcData, uint8* dstData, uint8* mask, int wid
for (bit = 0; bit < width % 8; bit++)
if ((bmask & (0x80 >> bit)) == 0)
*(icon + (height - y) * width + x + bit) |= 0xFF000000;
*(icon + (height - y - 1) * width + x + bit) |= 0xFF000000;
}
/* Skip padding */
@ -839,8 +839,6 @@ uint8* freerdp_icon_convert(uint8* srcData, uint8* dstData, uint8* mask, int wid
}
}
free(mask);
return dstData;
}

58
libfreerdp-core/listener.c
View File

@ -26,6 +26,7 @@
#ifndef _WIN32
#include <netdb.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <arpa/inet.h>
@ -121,6 +122,52 @@ static boolean freerdp_listener_open(freerdp_listener* instance, const char* bin
return (listener->num_sockfds > 0 ? true : false);
}
static boolean freerdp_listener_open_local(freerdp_listener* instance, const char* path)
{
#ifndef _WIN32
rdpListener* listener = (rdpListener*)instance->listener;
int status;
int sockfd;
struct sockaddr_un addr;
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sockfd == -1)
{
perror("socket");
return false;
}
fcntl(sockfd, F_SETFL, O_NONBLOCK);
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
unlink(path);
status = bind(sockfd, (struct sockaddr *) &addr, sizeof(addr));
if (status != 0)
{
perror("bind");
close(sockfd);
return false;
}
status = listen(sockfd, 10);
if (status != 0)
{
perror("listen");
close(sockfd);
return false;
}
listener->sockfds[listener->num_sockfds++] = sockfd;
printf("Listening on socket %s.\n", addr.sun_path);
return true;
#else
return false;
#endif
}
static void freerdp_listener_close(freerdp_listener* instance)
{
int i;
@ -187,12 +234,18 @@ static boolean freerdp_listener_check_fds(freerdp_listener* instance)
client = freerdp_peer_new(peer_sockfd);
sin_addr = NULL;
if (peer_addr.ss_family == AF_INET)
sin_addr = &(((struct sockaddr_in*) &peer_addr)->sin_addr);
else
else if (peer_addr.ss_family == AF_INET6)
sin_addr = &(((struct sockaddr_in6*) &peer_addr)->sin6_addr);
#ifndef _WIN32
else if (peer_addr.ss_family == AF_UNIX)
client->local = true;
#endif
inet_ntop(peer_addr.ss_family, sin_addr, client->hostname, sizeof(client->hostname));
if (sin_addr)
inet_ntop(peer_addr.ss_family, sin_addr, client->hostname, sizeof(client->hostname));
IFCALL(instance->PeerAccepted, instance, client);
}
@ -207,6 +260,7 @@ freerdp_listener* freerdp_listener_new(void)
instance = xnew(freerdp_listener);
instance->Open = freerdp_listener_open;
instance->OpenLocal = freerdp_listener_open_local;
instance->GetFileDescriptor = freerdp_listener_get_fds;
instance->CheckFileDescriptor = freerdp_listener_check_fds;
instance->Close = freerdp_listener_close;

9
libfreerdp-core/nego.c
View File

@ -600,9 +600,12 @@ boolean nego_send_negotiation_response(rdpNego* nego)
settings->tls_security = false;
settings->nla_security = false;
settings->rdp_security = true;
settings->encryption = true;
settings->encryption_method = ENCRYPTION_METHOD_40BIT | ENCRYPTION_METHOD_128BIT | ENCRYPTION_METHOD_FIPS;
settings->encryption_level = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE;
if (!settings->local)
{
settings->encryption = true;
settings->encryption_method = ENCRYPTION_METHOD_40BIT | ENCRYPTION_METHOD_128BIT | ENCRYPTION_METHOD_FIPS;
settings->encryption_level = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE;
}
}
else if (settings->selected_protocol == PROTOCOL_TLS)
{

1
libfreerdp-core/peer.c
View File

@ -26,6 +26,7 @@ static boolean freerdp_peer_initialize(freerdp_peer* client)
{
client->context->rdp->settings->server_mode = true;
client->context->rdp->settings->frame_acknowledge = 0;
client->context->rdp->settings->local = client->local;
client->context->rdp->state = CONNECTION_STATE_INITIAL;
if (client->context->rdp->settings->rdp_key_file != NULL)

55
libfreerdp-core/tcp.c
View File

@ -46,6 +46,7 @@
#endif
#include <freerdp/utils/tcp.h>
#include <freerdp/utils/uds.h>
#include <freerdp/utils/print.h>
#include <freerdp/utils/stream.h>
#include <freerdp/utils/memory.h>
@ -115,30 +116,40 @@ boolean tcp_connect(rdpTcp* tcp, const char* hostname, uint16 port)
uint32 option_value;
socklen_t option_len;
tcp->sockfd = freerdp_tcp_connect(hostname, port);
if (tcp->sockfd < 0)
return false;
tcp_get_ip_address(tcp);
tcp_get_mac_address(tcp);
option_value = 1;
option_len = sizeof(option_value);
setsockopt(tcp->sockfd, IPPROTO_TCP, TCP_NODELAY, (void*) &option_value, option_len);
/* receive buffer must be a least 32 K */
if (getsockopt(tcp->sockfd, SOL_SOCKET, SO_RCVBUF, (void*) &option_value, &option_len) == 0)
if (hostname[0] == '/')
{
if (option_value < (1024 * 32))
{
option_value = 1024 * 32;
option_len = sizeof(option_value);
setsockopt(tcp->sockfd, SOL_SOCKET, SO_RCVBUF, (void*) &option_value, option_len);
}
}
tcp->sockfd = freerdp_uds_connect(hostname);
tcp_set_keep_alive_mode(tcp);
if (tcp->sockfd < 0)
return false;
}
else
{
tcp->sockfd = freerdp_tcp_connect(hostname, port);
if (tcp->sockfd < 0)
return false;
tcp_get_ip_address(tcp);
tcp_get_mac_address(tcp);
option_value = 1;
option_len = sizeof(option_value);
setsockopt(tcp->sockfd, IPPROTO_TCP, TCP_NODELAY, (void*) &option_value, option_len);
/* receive buffer must be a least 32 K */
if (getsockopt(tcp->sockfd, SOL_SOCKET, SO_RCVBUF, (void*) &option_value, &option_len) == 0)
{
if (option_value < (1024 * 32))
{
option_value = 1024 * 32;
option_len = sizeof(option_value);
setsockopt(tcp->sockfd, SOL_SOCKET, SO_RCVBUF, (void*) &option_value, option_len);
}
}
tcp_set_keep_alive_mode(tcp);
}
return true;
}

1
libfreerdp-utils/CMakeLists.txt
View File

@ -47,6 +47,7 @@ set(FREERDP_UTILS_SRCS
tcp.c
thread.c
time.c
uds.c
unicode.c
wait_obj.c)

293
libfreerdp-utils/dsp.c
View File

@ -101,7 +101,7 @@ static uint16 dsp_decode_ima_adpcm_sample(ADPCM* adpcm,
sint32 ss;
sint32 d;
ss = ima_step_size_table[adpcm->last_step[channel]];
ss = ima_step_size_table[adpcm->ima.last_step[channel]];
d = (ss >> 3);
if (sample & 1)
d += (ss >> 2);
@ -111,20 +111,20 @@ static uint16 dsp_decode_ima_adpcm_sample(ADPCM* adpcm,
d += ss;
if (sample & 8)
d = -d;
d += adpcm->last_sample[channel];
d += adpcm->ima.last_sample[channel];
if (d < -32768)
d = -32768;
else if (d > 32767)
d = 32767;
adpcm->last_sample[channel] = (sint16) d;
adpcm->ima.last_sample[channel] = (sint16) d;
adpcm->last_step[channel] += ima_step_index_table[sample];
if (adpcm->last_step[channel] < 0)
adpcm->last_step[channel] = 0;
else if (adpcm->last_step[channel] > 88)
adpcm->last_step[channel] = 88;
adpcm->ima.last_step[channel] += ima_step_index_table[sample];
if (adpcm->ima.last_step[channel] < 0)
adpcm->ima.last_step[channel] = 0;
else if (adpcm->ima.last_step[channel] > 88)
adpcm->ima.last_step[channel] = 88;
return (uint16) d;
}
@ -150,15 +150,15 @@ static void freerdp_dsp_decode_ima_adpcm(FREERDP_DSP_CONTEXT* context,
{
if (size % block_size == 0)
{
context->adpcm.last_sample[0] = (sint16) (((uint16)(*src)) | (((uint16)(*(src + 1))) << 8));
context->adpcm.last_step[0] = (sint16) (*(src + 2));
context->adpcm.ima.last_sample[0] = (sint16) (((uint16)(*src)) | (((uint16)(*(src + 1))) << 8));
context->adpcm.ima.last_step[0] = (sint16) (*(src + 2));
src += 4;
size -= 4;
out_size -= 16;
if (channels > 1)
{
context->adpcm.last_sample[1] = (sint16) (((uint16)(*src)) | (((uint16)(*(src + 1))) << 8));
context->adpcm.last_step[1] = (sint16) (*(src + 2));
context->adpcm.ima.last_sample[1] = (sint16) (((uint16)(*src)) | (((uint16)(*(src + 1))) << 8));
context->adpcm.ima.last_step[1] = (sint16) (*(src + 2));
src += 4;
size -= 4;
out_size -= 16;
@ -198,7 +198,7 @@ static void freerdp_dsp_decode_ima_adpcm(FREERDP_DSP_CONTEXT* context,
}
}
context->adpcm_size = out_size;
context->adpcm_size = dst - context->adpcm_buffer;
}
/**
@ -241,8 +241,8 @@ static uint8 dsp_encode_ima_adpcm_sample(ADPCM* adpcm,
uint8 enc;
sint32 diff;
ss = ima_step_size_table[adpcm->last_step[channel]];
d = e = sample - adpcm->last_sample[channel];
ss = ima_step_size_table[adpcm->ima.last_step[channel]];
d = e = sample - adpcm->ima.last_sample[channel];
diff = ss >> 3;
enc = 0;
if (e < 0)
@ -273,18 +273,18 @@ static uint8 dsp_encode_ima_adpcm_sample(ADPCM* adpcm,
else
diff = d - e + diff;
diff += adpcm->last_sample[channel];
diff += adpcm->ima.last_sample[channel];
if (diff < -32768)
diff = -32768;
else if (diff > 32767)
diff = 32767;
adpcm->last_sample[channel] = (sint16) diff;
adpcm->ima.last_sample[channel] = (sint16) diff;
adpcm->last_step[channel] += ima_step_index_table[enc];
if (adpcm->last_step[channel] < 0)
adpcm->last_step[channel] = 0;
else if (adpcm->last_step[channel] > 88)
adpcm->last_step[channel] = 88;
adpcm->ima.last_step[channel] += ima_step_index_table[enc];
if (adpcm->ima.last_step[channel] < 0)
adpcm->ima.last_step[channel] = 0;
else if (adpcm->ima.last_step[channel] > 88)
adpcm->ima.last_step[channel] = 88;
return enc;
}
@ -309,15 +309,15 @@ static void freerdp_dsp_encode_ima_adpcm(FREERDP_DSP_CONTEXT* context,
{
if ((dst - context->adpcm_buffer) % block_size == 0)
{
*dst++ = context->adpcm.last_sample[0] & 0xff;
*dst++ = (context->adpcm.last_sample[0] >> 8) & 0xff;
*dst++ = (uint8) context->adpcm.last_step[0];
*dst++ = context->adpcm.ima.last_sample[0] & 0xff;
*dst++ = (context->adpcm.ima.last_sample[0] >> 8) & 0xff;
*dst++ = (uint8) context->adpcm.ima.last_step[0];
*dst++ = 0;
if (channels > 1)
{
*dst++ = context->adpcm.last_sample[1] & 0xff;
*dst++ = (context->adpcm.last_sample[1] >> 8) & 0xff;
*dst++ = (uint8) context->adpcm.last_step[1];
*dst++ = context->adpcm.ima.last_sample[1] & 0xff;
*dst++ = (context->adpcm.ima.last_sample[1] >> 8) & 0xff;
*dst++ = (uint8) context->adpcm.ima.last_step[1];
*dst++ = 0;
}
}
@ -351,6 +351,241 @@ static void freerdp_dsp_encode_ima_adpcm(FREERDP_DSP_CONTEXT* context,
context->adpcm_size = dst - context->adpcm_buffer;
}
/**
* Microsoft ADPCM Specification:
*
* http://wiki.multimedia.cx/index.php?title=Microsoft_ADPCM
*/
static const sint16 ms_adpcm_adaptation_table[] =
{
230, 230, 230, 230, 307, 409, 512, 614,
768, 614, 512, 409, 307, 230, 230, 230
};
static const sint16 ms_adpcm_coeff1_table[] =
{
256, 512, 0, 192, 240, 460, 392
};
static const sint16 ms_adpcm_coeff2_table[] =
{
0, -256, 0, 64, 0, -208, -232
};
static sint16 freerdp_dsp_decode_ms_adpcm_sample(ADPCM* adpcm, uint8 sample, int channel)
{
sint8 nibble;
sint32 presample;
nibble = (sample & 0x08 ? (sint8)sample - 16 : sample);
presample = ((adpcm->ms.sample1[channel] * ms_adpcm_coeff1_table[adpcm->ms.predictor[channel]]) +
(adpcm->ms.sample2[channel] * ms_adpcm_coeff2_table[adpcm->ms.predictor[channel]])) / 256;
presample += nibble * adpcm->ms.delta[channel];
if (presample > 32767)
presample = 32767;
else if (presample < -32768)
presample = -32768;
adpcm->ms.sample2[channel] = adpcm->ms.sample1[channel];
adpcm->ms.sample1[channel] = presample;
adpcm->ms.delta[channel] = adpcm->ms.delta[channel] * ms_adpcm_adaptation_table[sample] / 256;
if (adpcm->ms.delta[channel] < 16)
adpcm->ms.delta[channel] = 16;
return (sint16) presample;
}
static void freerdp_dsp_decode_ms_adpcm(FREERDP_DSP_CONTEXT* context,
const uint8* src, int size, int channels, int block_size)
{
uint8* dst;
uint8 sample;
uint32 out_size;
out_size = size * 4;
if (out_size > context->adpcm_maxlength)
{
context->adpcm_maxlength = out_size + 1024;
context->adpcm_buffer = xrealloc(context->adpcm_buffer, context->adpcm_maxlength);
}
dst = context->adpcm_buffer;
while (size > 0)
{
if (size % block_size == 0)
{
if (channels > 1)
{
context->adpcm.ms.predictor[0] = *src++;
context->adpcm.ms.predictor[1] = *src++;
context->adpcm.ms.delta[0] = *((sint16*)src);
src += 2;
context->adpcm.ms.delta[1] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample1[0] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample1[1] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample2[0] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample2[1] = *((sint16*)src);
src += 2;
size -= 14;
*((sint16*)dst) = context->adpcm.ms.sample2[0];
dst += 2;
*((sint16*)dst) = context->adpcm.ms.sample2[1];
dst += 2;
*((sint16*)dst) = context->adpcm.ms.sample1[0];
dst += 2;
*((sint16*)dst) = context->adpcm.ms.sample1[1];
dst += 2;
}
else
{
context->adpcm.ms.predictor[0] = *src++;
context->adpcm.ms.delta[0] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample1[0] = *((sint16*)src);
src += 2;
context->adpcm.ms.sample2[0] = *((sint16*)src);
src += 2;
size -= 7;
*((sint16*)dst) = context->adpcm.ms.sample2[0];
dst += 2;
*((sint16*)dst) = context->adpcm.ms.sample1[0];
dst += 2;
}
}
if (channels > 1)
{
sample = *src++;
size--;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0);
dst += 2;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 1);
dst += 2;
sample = *src++;
size--;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0);
dst += 2;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 1);
dst += 2;
}
else
{
sample = *src++;
size--;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample >> 4, 0);
dst += 2;
*((sint16*)dst) = freerdp_dsp_decode_ms_adpcm_sample(&context->adpcm, sample & 0x0F, 0);
dst += 2;
}
}
context->adpcm_size = dst - context->adpcm_buffer;
}
static uint8 freerdp_dsp_encode_ms_adpcm_sample(ADPCM* adpcm, sint32 sample, int channel)
{
sint32 presample;
sint32 errordelta;
presample = ((adpcm->ms.sample1[channel] * ms_adpcm_coeff1_table[adpcm->ms.predictor[channel]]) +
(adpcm->ms.sample2[channel] * ms_adpcm_coeff2_table[adpcm->ms.predictor[channel]])) / 256;
errordelta = (sample - presample) / adpcm->ms.delta[channel];
if ((sample - presample) % adpcm->ms.delta[channel] > adpcm->ms.delta[channel] / 2)
errordelta++;
if (errordelta > 7)
errordelta = 7;
else if (errordelta < -8)
errordelta = -8;
presample += adpcm->ms.delta[channel] * errordelta;
if (presample > 32767)
presample = 32767;
else if (presample < -32768)
presample = -32768;
adpcm->ms.sample2[channel] = adpcm->ms.sample1[channel];
adpcm->ms.sample1[channel] = presample;
adpcm->ms.delta[channel] = adpcm->ms.delta[channel] * ms_adpcm_adaptation_table[(((uint8)errordelta) & 0x0F)] / 256;
if (adpcm->ms.delta[channel] < 16)
adpcm->ms.delta[channel] = 16;
return ((uint8)errordelta) & 0x0F;
}
static void freerdp_dsp_encode_ms_adpcm(FREERDP_DSP_CONTEXT* context,
const uint8* src, int size, int channels, int block_size)
{
uint8* dst;
sint32 sample;
uint32 out_size;
out_size = size / 2;
if (out_size > context->adpcm_maxlength)
{
context->adpcm_maxlength = out_size + 1024;
context->adpcm_buffer = xrealloc(context->adpcm_buffer, context->adpcm_maxlength);
}
dst = context->adpcm_buffer;
if (context->adpcm.ms.delta[0] < 16)
context->adpcm.ms.delta[0] = 16;
if (context->adpcm.ms.delta[1] < 16)
context->adpcm.ms.delta[1] = 16;
while (size > 0)
{
if ((dst - context->adpcm_buffer) % block_size == 0)
{
if (channels > 1)
{
*dst++ = context->adpcm.ms.predictor[0];
*dst++ = context->adpcm.ms.predictor[1];
*dst++ = (uint8) (context->adpcm.ms.delta[0] & 0xff);
*dst++ = (uint8) ((context->adpcm.ms.delta[0] >> 8) & 0xff);
*dst++ = (uint8) (context->adpcm.ms.delta[1] & 0xff);
*dst++ = (uint8) ((context->adpcm.ms.delta[1] >> 8) & 0xff);
context->adpcm.ms.sample1[0] = *((sint16*) (src + 4));
context->adpcm.ms.sample1[1] = *((sint16*) (src + 6));
context->adpcm.ms.sample2[0] = *((sint16*) (src + 0));
context->adpcm.ms.sample2[1] = *((sint16*) (src + 2));
*((sint16*) (dst + 0)) = (sint16) context->adpcm.ms.sample1[0];
*((sint16*) (dst + 2)) = (sint16) context->adpcm.ms.sample1[1];
*((sint16*) (dst + 4)) = (sint16) context->adpcm.ms.sample2[0];
*((sint16*) (dst + 6)) = (sint16) context->adpcm.ms.sample2[1];
dst += 8;
src += 8;
size -= 8;
}
else
{
*dst++ = context->adpcm.ms.predictor[0];
*dst++ = (uint8) (context->adpcm.ms.delta[0] & 0xff);
*dst++ = (uint8) ((context->adpcm.ms.delta[0] >> 8) & 0xff);
context->adpcm.ms.sample1[0] = *((sint16*) (src + 2));
context->adpcm.ms.sample2[0] = *((sint16*) (src + 0));
*((sint16*) (dst + 0)) = (sint16) context->adpcm.ms.sample1[0];
*((sint16*) (dst + 2)) = (sint16) context->adpcm.ms.sample2[0];
dst += 4;
src += 4;
size -= 4;
}
}
sample = *((sint16*) src);
src += 2;
*dst = freerdp_dsp_encode_ms_adpcm_sample(&context->adpcm, sample, 0) << 4;
sample = *((sint16*) src);
src += 2;
*dst += freerdp_dsp_encode_ms_adpcm_sample(&context->adpcm, sample, channels > 1 ? 1 : 0);
dst++;
size -= 4;
}
context->adpcm_size = dst - context->adpcm_buffer;
}
FREERDP_DSP_CONTEXT* freerdp_dsp_context_new(void)
{
FREERDP_DSP_CONTEXT* context;
@ -360,6 +595,8 @@ FREERDP_DSP_CONTEXT* freerdp_dsp_context_new(void)
context->resample = freerdp_dsp_resample;
context->decode_ima_adpcm = freerdp_dsp_decode_ima_adpcm;
context->encode_ima_adpcm = freerdp_dsp_encode_ima_adpcm;
context->decode_ms_adpcm = freerdp_dsp_decode_ms_adpcm;
context->encode_ms_adpcm = freerdp_dsp_encode_ms_adpcm;
return context;
}

2
libfreerdp-utils/list.c
View File

@ -1,4 +1,4 @@
/**
/*
* FreeRDP: A Remote Desktop Protocol Client
* Double-linked List Utils
*

70
libfreerdp-utils/memory.c
View File

@ -1,4 +1,4 @@
/**
/*
* FreeRDP: A Remote Desktop Protocol Client
* Memory Utils
*
@ -25,7 +25,12 @@
/**
* Allocate memory.
* @param size
* This function is used to secure a malloc call.
* It verifies its return value, and logs an error if the allocation failed.
*
* @param size - number of bytes to allocate. If the size is < 1, it will default to 1.
*
* @return a pointer to the allocated buffer. NULL if the allocation failed.
*/
void* xmalloc(size_t size)
@ -48,9 +53,13 @@ void* xmalloc(size_t size)
/**
* Allocate memory initialized to zero.
* @param size
* This function is used to secure a calloc call.
* It verifies its return value, and logs an error if the allocation failed.
*
* @param size - number of bytes to allocate. If the size is < 1, it will default to 1.
*
* @return a pointer to the allocated and zeroed buffer. NULL if the allocation failed.
*/
void* xzalloc(size_t size)
{
void* mem;
@ -71,8 +80,13 @@ void* xzalloc(size_t size)
/**
* Reallocate memory.
* @param ptr
* @param size
* This function is used to secure a realloc call.
* It verifies its return value, and logs an error if the allocation failed.
*
* @param ptr - pointer to the buffer that needs reallocation. This can be NULL, in which case a new buffer is allocated.
* @param size - number of bytes to allocate. If the size is < 1, it will default to 1.
*
* @return a pointer to the reallocated buffer. NULL if the allocation failed (in which case the 'ptr' argument is untouched).
*/
void* xrealloc(void* ptr, size_t size)
@ -92,7 +106,10 @@ void* xrealloc(void* ptr, size_t size)
/**
* Free memory.
* @param mem
* This function is used to secure a free call.
* It verifies that the pointer is valid (non-NULL) before trying to deallocate it's buffer.
*
* @param ptr - pointer to a buffer that needs deallocation. If ptr is NULL, nothing will be done (no segfault).
*/
void xfree(void* ptr)
@ -103,8 +120,14 @@ void xfree(void* ptr)
/**
* Duplicate a string in memory.
* @param str
* @return
* This function is used to secure the strdup function.
* It will allocate a new memory buffer and copy the string content in it.
* If allocation fails, it will log an error.
*
* @param str - pointer to the character string to copy. If str is NULL, nothing is done.
*
* @return a pointer to a newly allocated character string containing the same bytes as str.
* NULL if an allocation error occurred, or if the str parameter was NULL.
*/
char* xstrdup(const char* str)
@ -127,9 +150,14 @@ char* xstrdup(const char* str)
}
/**
* Duplicate a string in memory.
* @param wstr
* @return
* Duplicate a wide string in memory.
* This function is used to secure a call to wcsdup.
* It verifies the return value, and logs a message if an allocation error occurred.
*
* @param wstr - pointer to the wide-character string to duplicate. If wstr is NULL, nothing will be done.
*
* @return a pointer to the newly allocated string, containing the same data as wstr.
* NULL if an allocation error occurred (or if wstr was NULL).
*/
wchar_t* xwcsdup(const wchar_t* wstr)
@ -143,6 +171,10 @@ wchar_t* xwcsdup(const wchar_t* wstr)
mem = _wcsdup(wstr);
#elif sun
mem = wsdup(wstr);
#elif (defined(__APPLE__) && defined(__MACH__)) || defined(ANDROID)
mem = xmalloc(wcslen(wstr));
if (mem != NULL)
wcscpy(mem, wstr);
#else
mem = wcsdup(wstr);
#endif
@ -153,6 +185,16 @@ wchar_t* xwcsdup(const wchar_t* wstr)
return mem;
}
/**
* Create an uppercase version of the given string.
* This function will duplicate the string (using xstrdup()) and change its content to all uppercase.
* The original string is untouched.
*
* @param str - pointer to the character string to convert. This content is untouched by the function.
*
* @return pointer to a newly allocated character string, containing the same content as str, converted to uppercase.
* NULL if an allocation error occured.
*/
char* xstrtoup(const char* str)
{
char* out;
@ -167,8 +209,6 @@ char* xstrtoup(const char* str)
c = toupper((unsigned char)*p);
*p++ = (char)c;
}
return out;
}
else
return NULL;
return out;
}

43
libfreerdp-utils/mutex.c
View File

@ -1,4 +1,4 @@
/**
/*
* FreeRDP: A Remote Desktop Protocol Client
* Mutex Utils
*
@ -28,6 +28,22 @@
#define freerdp_mutex_t pthread_mutex_t
#endif
/**
* Mutex are used to prevent concurrent accesses to specific portions of code.
* This funciton and the other freerdp_mutex_*() function are defining a portable API
* to get mutex for both Windows and Linux, where the lower level implementation is very different.
*
* This function creates a new freerdp_mutex object.
* Use freerdp_mutex_lock() to get exclusive ownership of the mutex, and lock a given (protected) portion of code.
* Use freerdp_mutex_unlock() to release your ownership on a mutex.
* Use freerdp_mutex_free() to release the resources associated with the mutex when it is no longer needed.
*
* @return a freerdp_mutex pointer. This should be considered opaque, as the implementation is platform dependent.
* NULL is returned if an allocation or initialization error occurred.
*
* @see pthread documentation for Linux implementation of mutexes
* @see MSDN http://msdn.microsoft.com/en-us/library/windows/desktop/ms682411%28v=vs.85%29.aspx for Windows implementation
*/
freerdp_mutex freerdp_mutex_new(void)
{
#ifdef _WIN32
@ -37,11 +53,18 @@ freerdp_mutex freerdp_mutex_new(void)
#else
freerdp_mutex_t* mutex;
mutex = xnew(freerdp_mutex_t);
pthread_mutex_init(mutex, 0);
if (mutex)
pthread_mutex_init(mutex, 0);
return mutex;
#endif
}
/**
* This function is used to deallocate all resources associated with a freerdp_mutex object.
*
* @param mutex [in] - Pointer to the mutex that needs to be deallocated.
* On return, this object is not valid anymore.
*/
void freerdp_mutex_free(freerdp_mutex mutex)
{
#ifdef _WIN32
@ -52,6 +75,15 @@ void freerdp_mutex_free(freerdp_mutex mutex)
#endif
}
/**
* Use this function to get exclusive ownership of the mutex.
* This should be called before entering a portion of code that needs to be protected against concurrent accesses.
* Use the freerdp_mutex_unlock() call to release ownership when you leave this protected code.
*
* @param mutex [in] - An initialized freerdp_mutex object, as returned from a call to freerdp_mutex_new().
* This function will suspend the running thread when called, until the mutex is available.
* Only one thread at a time will be allowed to continue execution.
*/
void freerdp_mutex_lock(freerdp_mutex mutex)
{
#ifdef _WIN32
@ -61,6 +93,13 @@ void freerdp_mutex_lock(freerdp_mutex mutex)
#endif
}
/**
* Use this function to release your ownership on a mutex.
* This should be called when leaving a portion of code that needs to be protected against concurrent accesses.
* DO NOT use this call on a mutex that you do not own. See freerdp_mutex_lock() for getting ownership on a mutex.
*
* @param mutex [in] - Pointer to a mutex that was locked by a call to freerdp_mutex_lock().
*/
void freerdp_mutex_unlock(freerdp_mutex mutex)
{
#ifdef _WIN32

74
libfreerdp-utils/uds.c Normal file
View File

@ -0,0 +1,74 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* Unix Domain Socket Utils
*
* Copyright 2012 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/utils/uds.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#ifndef _WIN32
#include <netdb.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <net/if.h>
#endif
int freerdp_uds_connect(const char* path)
{
#ifndef _WIN32
int status;
int sockfd;
struct sockaddr_un addr;
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sockfd == -1)
{
perror("socket");
return -1;
}
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
status = connect(sockfd, (struct sockaddr *) &addr, sizeof(addr));
if (status < 0)
{
perror("connect");
close(sockfd);
return -1;
}
return sockfd;
#else /* ifndef _WIN32 */
return -1;
#endif
}

4
server/CMakeLists.txt
View File

@ -29,5 +29,7 @@ if(NOT WIN32)
if(WITH_X11)
add_subdirectory(X11)
endif()
# Build Server Channels library
add_subdirectory(channels)
endif()

30
server/channels/CMakeLists.txt Normal file
View File

@ -0,0 +1,30 @@
# FreeRDP: A Remote Desktop Protocol Client
# libfreerdp-server-channels cmake build script
#
# Copyright 2011 O.S. Systems Software Ltda.
# Copyright 2011 Otavio Salvador <otavio@ossystems.com.br>
# Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set(FREERDP_SERVER_CHANNELS_SRCS
rdpsnd.c
)
add_library(freerdp-server-channels ${FREERDP_SERVER_CHANNELS_SRCS})
set_target_properties(freerdp-server-channels PROPERTIES VERSION ${FREERDP_VERSION_FULL} SOVERSION ${FREERDP_VERSION} PREFIX "lib")
target_link_libraries(freerdp-server-channels freerdp-channels freerdp-utils)
install(TARGETS freerdp-server-channels DESTINATION ${CMAKE_INSTALL_LIBDIR})

452
server/channels/rdpsnd.c Normal file
View File

@ -0,0 +1,452 @@
/**
* FreeRDP: A Remote Desktop Protocol client.
* Server Audio Virtual Channel
*
* Copyright 2012 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <freerdp/utils/stream.h>
#include <freerdp/utils/memory.h>
#include <freerdp/utils/dsp.h>
#include <freerdp/utils/thread.h>
#include <freerdp/utils/wait_obj.h>
#include <freerdp/channels/wtsvc.h>
#include <freerdp/server/rdpsnd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct _rdpsnd_server
{
rdpsnd_server_context context;
void* rdpsnd_channel;
freerdp_thread* rdpsnd_channel_thread;
STREAM* rdpsnd_pdu;
FREERDP_DSP_CONTEXT* dsp_context;
uint8* out_buffer;
int out_buffer_size;
int out_frames;
int out_pending_frames;
uint32 src_bytes_per_sample;
uint32 src_bytes_per_frame;
} rdpsnd_server;
#define RDPSND_PDU_INIT(_s, _msgType) \
{ \
stream_write_uint8(_s, _msgType); \
stream_write_uint8(_s, 0); \
stream_seek_uint16(_s); \
}
#define RDPSND_PDU_FINISH(_s) \
{ \
boolean _r; \
int _pos; \
_pos = stream_get_pos(_s); \
stream_set_pos(_s, 2); \
stream_write_uint16(_s, _pos - 4); \
stream_set_pos(_s, _pos); \
_r = WTSVirtualChannelWrite(rdpsnd->rdpsnd_channel, stream_get_head(_s), stream_get_length(_s), NULL); \
stream_set_pos(_s, 0); \
return _r; \
}
static boolean rdpsnd_server_send_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
uint16 i;
RDPSND_PDU_INIT(s, SNDC_FORMATS);
stream_write_uint32(s, 0); /* dwFlags */
stream_write_uint32(s, 0); /* dwVolume */
stream_write_uint32(s, 0); /* dwPitch */
stream_write_uint16(s, 0); /* wDGramPort */
stream_write_uint16(s, rdpsnd->context.num_server_formats); /* wNumberOfFormats */
stream_write_uint8(s, rdpsnd->context.block_no); /* cLastBlockConfirmed */
stream_write_uint16(s, 0x06); /* wVersion */
stream_write_uint8(s, 0); /* bPad */
for (i = 0; i < rdpsnd->context.num_server_formats; i++)
{
stream_write_uint16(s, rdpsnd->context.server_formats[i].wFormatTag); /* wFormatTag (WAVE_FORMAT_PCM) */
stream_write_uint16(s, rdpsnd->context.server_formats[i].nChannels); /* nChannels */
stream_write_uint32(s, rdpsnd->context.server_formats[i].nSamplesPerSec); /* nSamplesPerSec */
stream_write_uint32(s, rdpsnd->context.server_formats[i].nSamplesPerSec *
rdpsnd->context.server_formats[i].nChannels *
rdpsnd->context.server_formats[i].wBitsPerSample / 8); /* nAvgBytesPerSec */
stream_write_uint16(s, rdpsnd->context.server_formats[i].nBlockAlign); /* nBlockAlign */
stream_write_uint16(s, rdpsnd->context.server_formats[i].wBitsPerSample); /* wBitsPerSample */
stream_write_uint16(s, rdpsnd->context.server_formats[i].cbSize); /* cbSize */
if (rdpsnd->context.server_formats[i].cbSize > 0)
{
stream_write(s, rdpsnd->context.server_formats[i].data, rdpsnd->context.server_formats[i].cbSize);
}
}
RDPSND_PDU_FINISH(s);
}
static boolean rdpsnd_server_recv_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
int i;
if (stream_get_left(s) < 20)
return false;
stream_seek_uint32(s); /* dwFlags */
stream_seek_uint32(s); /* dwVolume */
stream_seek_uint32(s); /* dwPitch */
stream_seek_uint16(s); /* wDGramPort */
stream_read_uint16(s, rdpsnd->context.num_client_formats); /* wNumberOfFormats */
stream_seek_uint8(s); /* cLastBlockConfirmed */
stream_seek_uint16(s); /* wVersion */
stream_seek_uint8(s); /* bPad */
if (rdpsnd->context.num_client_formats > 0)
{
rdpsnd->context.client_formats = xzalloc(rdpsnd->context.num_client_formats * sizeof(rdpsndFormat));
for (i = 0; i < rdpsnd->context.num_client_formats; i++)
{
if (stream_get_left(s) < 18)
{
xfree(rdpsnd->context.client_formats);
rdpsnd->context.client_formats = NULL;
return false;
}
stream_read_uint16(s, rdpsnd->context.client_formats[i].wFormatTag);
stream_read_uint16(s, rdpsnd->context.client_formats[i].nChannels);
stream_read_uint32(s, rdpsnd->context.client_formats[i].nSamplesPerSec);
stream_seek_uint32(s); /* nAvgBytesPerSec */
stream_read_uint16(s, rdpsnd->context.client_formats[i].nBlockAlign);
stream_read_uint16(s, rdpsnd->context.client_formats[i].wBitsPerSample);
stream_read_uint16(s, rdpsnd->context.client_formats[i].cbSize);
if (rdpsnd->context.client_formats[i].cbSize > 0)
{
stream_seek(s, rdpsnd->context.client_formats[i].cbSize);
}
}
}
return true;
}
static void* rdpsnd_server_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
uint8 msgType;
uint16 BodySize;
uint32 bytes_returned = 0;
rdpsnd_server* rdpsnd = (rdpsnd_server*) arg;
freerdp_thread* thread = rdpsnd->rdpsnd_channel_thread;
if (WTSVirtualChannelQuery(rdpsnd->rdpsnd_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == true)
{
fd = *((void**)buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = wait_obj_new_with_fd(fd);
}
s = stream_new(4096);
rdpsnd_server_send_formats(rdpsnd, s);
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(rdpsnd->rdpsnd_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
{
if (bytes_returned == 0)
break;
stream_check_size(s, bytes_returned);
if (WTSVirtualChannelRead(rdpsnd->rdpsnd_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
break;
}
stream_read_uint8(s, msgType);
stream_seek_uint8(s); /* bPad */
stream_read_uint16(s, BodySize);
if (BodySize + 4 > bytes_returned)
continue;
switch (msgType) {
case SNDC_FORMATS:
if (rdpsnd_server_recv_formats(rdpsnd, s))
{
IFCALL(rdpsnd->context.Activated, &rdpsnd->context);
}
break;
default:
break;
}
}
stream_free(s);
freerdp_thread_quit(thread);
return 0;
}
static boolean rdpsnd_server_initialize(rdpsnd_server_context* context)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
rdpsnd->rdpsnd_channel = WTSVirtualChannelOpenEx(context->vcm, "rdpsnd", 0);
if (rdpsnd->rdpsnd_channel != NULL)
{
rdpsnd->rdpsnd_pdu = stream_new(4096);
rdpsnd->rdpsnd_channel_thread = freerdp_thread_new();
freerdp_thread_start(rdpsnd->rdpsnd_channel_thread, rdpsnd_server_thread_func, rdpsnd);
return true;
}
else
{
return false;
}
}
static void rdpsnd_server_select_format(rdpsnd_server_context* context, int client_format_index)
{
int bs;
int out_buffer_size;
rdpsndFormat *format;
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
if (client_format_index < 0 || client_format_index >= context->num_client_formats)
{
printf("rdpsnd_server_select_format: index %d is not correct.\n", client_format_index);
return;
}
rdpsnd->src_bytes_per_sample = context->src_format.wBitsPerSample / 8;
rdpsnd->src_bytes_per_frame = rdpsnd->src_bytes_per_sample * context->src_format.nChannels;
context->selected_client_format = client_format_index;
format = &context->client_formats[client_format_index];
if (format->wFormatTag == 0x11)
{
bs = (format->nBlockAlign - 4 * format->nChannels) * 4;
rdpsnd->out_frames = (format->nBlockAlign * 4 * format->nChannels * 2 / bs + 1) * bs / (format->nChannels * 2);
}
else if (format->wFormatTag == 0x02)
{
bs = (format->nBlockAlign - 7 * format->nChannels) * 2 / format->nChannels + 2;
rdpsnd->out_frames = bs * 4;
}
else
{
rdpsnd->out_frames = 0x4000 / rdpsnd->src_bytes_per_frame;
}
if (format->nSamplesPerSec != context->src_format.nSamplesPerSec)
{
rdpsnd->out_frames = (rdpsnd->out_frames * context->src_format.nSamplesPerSec + format->nSamplesPerSec - 100) / format->nSamplesPerSec;
}
rdpsnd->out_pending_frames = 0;
out_buffer_size = rdpsnd->out_frames * rdpsnd->src_bytes_per_frame;
if (rdpsnd->out_buffer_size < out_buffer_size)
{
rdpsnd->out_buffer = xrealloc(rdpsnd->out_buffer, out_buffer_size);
rdpsnd->out_buffer_size = out_buffer_size;
}
freerdp_dsp_context_reset_adpcm(rdpsnd->dsp_context);
}
static boolean rdpsnd_server_send_audio_pdu(rdpsnd_server* rdpsnd)
{
STREAM* s = rdpsnd->rdpsnd_pdu;
rdpsndFormat* format;
int tbytes_per_frame;
uint8* src;
int size;
int frames;
int fill_size;
boolean r;
format = &rdpsnd->context.client_formats[rdpsnd->context.selected_client_format];
tbytes_per_frame = format->nChannels * rdpsnd->src_bytes_per_sample;
if (format->nSamplesPerSec == rdpsnd->context.src_format.nSamplesPerSec && format->nChannels == rdpsnd->context.src_format.nChannels)
{
src = rdpsnd->out_buffer;
frames = rdpsnd->out_pending_frames;
}
else
{
rdpsnd->dsp_context->resample(rdpsnd->dsp_context, rdpsnd->out_buffer, rdpsnd->src_bytes_per_sample,
rdpsnd->context.src_format.nChannels, rdpsnd->context.src_format.nSamplesPerSec, rdpsnd->out_pending_frames,
format->nChannels, format->nSamplesPerSec);
frames = rdpsnd->dsp_context->resampled_frames;
src = rdpsnd->dsp_context->resampled_buffer;
}
size = frames * tbytes_per_frame;
if (format->wFormatTag == 0x11)
{
rdpsnd->dsp_context->encode_ima_adpcm(rdpsnd->dsp_context,
src, size, format->nChannels, format->nBlockAlign);
src = rdpsnd->dsp_context->adpcm_buffer;
size = rdpsnd->dsp_context->adpcm_size;
}
else if (format->wFormatTag == 0x02)
{
rdpsnd->dsp_context->encode_ms_adpcm(rdpsnd->dsp_context,
src, size, format->nChannels, format->nBlockAlign);
src = rdpsnd->dsp_context->adpcm_buffer;
size = rdpsnd->dsp_context->adpcm_size;
}
rdpsnd->context.block_no = (rdpsnd->context.block_no + 1) % 256;
/* Fill to nBlockAlign for the last audio packet */
if ((format->wFormatTag == 0x11 || format->wFormatTag == 0x02) &&
rdpsnd->out_pending_frames < rdpsnd->out_frames && (size % format->nBlockAlign) != 0)
fill_size = format->nBlockAlign - (size % format->nBlockAlign);
else
fill_size = 0;
/* WaveInfo PDU */
stream_set_pos(s, 0);
stream_write_uint8(s, SNDC_WAVE); /* msgType */
stream_write_uint8(s, 0); /* bPad */
stream_write_uint16(s, size + fill_size + 8); /* BodySize */
stream_write_uint16(s, 0); /* wTimeStamp */
stream_write_uint16(s, rdpsnd->context.selected_client_format); /* wFormatNo */
stream_write_uint8(s, rdpsnd->context.block_no); /* cBlockNo */
stream_seek(s, 3); /* bPad */
stream_write(s, src, 4);
WTSVirtualChannelWrite(rdpsnd->rdpsnd_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_set_pos(s, 0);
/* Wave PDU */
stream_check_size(s, size + fill_size);
stream_write_uint32(s, 0); /* bPad */
stream_write(s, src + 4, size - 4);
if (fill_size > 0)
stream_write_zero(s, fill_size);
r = WTSVirtualChannelWrite(rdpsnd->rdpsnd_channel, stream_get_head(s), stream_get_length(s), NULL);
stream_set_pos(s, 0);
rdpsnd->out_pending_frames = 0;
return r;
}
static boolean rdpsnd_server_send_samples(rdpsnd_server_context* context, const void* buf, int nframes)
{
int cframes;
int cframesize;
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
if (rdpsnd->context.selected_client_format < 0)
return false;
while (nframes > 0)
{
cframes = MIN(nframes, rdpsnd->out_frames - rdpsnd->out_pending_frames);
cframesize = cframes * rdpsnd->src_bytes_per_frame;
memcpy(rdpsnd->out_buffer + (rdpsnd->out_pending_frames * rdpsnd->src_bytes_per_frame),
buf, cframesize);
buf = (uint8*)buf + cframesize;
nframes -= cframes;
rdpsnd->out_pending_frames += cframes;
if (rdpsnd->out_pending_frames >= rdpsnd->out_frames)
{
if (!rdpsnd_server_send_audio_pdu(rdpsnd))
return false;
}
}
return true;
}
static boolean rdpsnd_server_close(rdpsnd_server_context* context)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
STREAM* s = rdpsnd->rdpsnd_pdu;
if (rdpsnd->context.selected_client_format < 0)
return false;
if (rdpsnd->out_pending_frames > 0)
{
if (!rdpsnd_server_send_audio_pdu(rdpsnd))
return false;
}
rdpsnd->context.selected_client_format = -1;
RDPSND_PDU_INIT(s, SNDC_CLOSE);
RDPSND_PDU_FINISH(s);
}
rdpsnd_server_context* rdpsnd_server_context_new(WTSVirtualChannelManager* vcm)
{
rdpsnd_server* rdpsnd;
rdpsnd = xnew(rdpsnd_server);
rdpsnd->context.vcm = vcm;
rdpsnd->context.selected_client_format = -1;
rdpsnd->context.Initialize = rdpsnd_server_initialize;
rdpsnd->context.SelectFormat = rdpsnd_server_select_format;
rdpsnd->context.SendSamples = rdpsnd_server_send_samples;
rdpsnd->context.Close = rdpsnd_server_close;
rdpsnd->dsp_context = freerdp_dsp_context_new();
return (rdpsnd_server_context*) rdpsnd;
}
void rdpsnd_server_context_free(rdpsnd_server_context* context)
{
rdpsnd_server* rdpsnd = (rdpsnd_server*) context;
if (rdpsnd->rdpsnd_channel_thread)
{
freerdp_thread_stop(rdpsnd->rdpsnd_channel_thread);
freerdp_thread_free(rdpsnd->rdpsnd_channel_thread);
}
if (rdpsnd->rdpsnd_channel)
WTSVirtualChannelClose(rdpsnd->rdpsnd_channel);
if (rdpsnd->rdpsnd_pdu)
stream_free(rdpsnd->rdpsnd_pdu);
if (rdpsnd->out_buffer)
xfree(rdpsnd->out_buffer);
if (rdpsnd->dsp_context)
freerdp_dsp_context_free(rdpsnd->dsp_context);
if (rdpsnd->context.client_formats)
xfree(rdpsnd->context.client_formats);
xfree(rdpsnd);
}

9
server/test/tfreerdp.c
View File

@ -461,7 +461,7 @@ boolean tf_peer_post_connect(freerdp_peer* client)
* The server may start sending graphics output and receiving keyboard/mouse input after this
* callback returns.
*/
printf("Client %s is activated (osMajorType %d osMinorType %d)", client->hostname,
printf("Client %s is activated (osMajorType %d osMinorType %d)", client->local ? "(local)" : client->hostname,
client->settings->os_major_type, client->settings->os_minor_type);
if (client->settings->autologon)
{
@ -613,7 +613,7 @@ static void* test_peer_mainloop(void* arg)
client->Initialize(client);
context = (testPeerContext*) client->context;
printf("We've got a client %s\n", client->hostname);
printf("We've got a client %s\n", client->local ? "(local)" : client->hostname);
while (1)
{
@ -661,7 +661,7 @@ static void* test_peer_mainloop(void* arg)
break;
}
printf("Client %s disconnected.\n", client->hostname);
printf("Client %s disconnected.\n", client->local ? "(local)" : client->hostname);
client->Disconnect(client);
freerdp_peer_context_free(client);
@ -756,7 +756,8 @@ int main(int argc, char* argv[])
test_dump_rfx_realtime = false;
/* Open the server socket and start listening. */
if (instance->Open(instance, NULL, 3389))
if (instance->Open(instance, NULL, 3389) &&
instance->OpenLocal(instance, "/tmp/tfreerdp-server.0"))
{
/* Entering the server main loop. In a real server the listener can be run in its own thread. */
test_server_mainloop(instance);