mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #612 from llyzs/server

Browse Source 
server: add rdpsnd server channel library.
This commit is contained in:
Vic Lee 2012-05-24 19:44:11 -07:00
commit e91ca7e73d
12 changed files with 943 additions and 68 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;

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

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

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);

293
libfreerdp-utils/dsp.c
View File

@ -100,7 +100,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);
@ -110,20 +110,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;
}
@ -149,15 +149,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;
@ -197,7 +197,7 @@ static void freerdp_dsp_decode_ima_adpcm(FREERDP_DSP_CONTEXT* context,
}
}
context->adpcm_size = out_size;
context->adpcm_size = dst - context->adpcm_buffer;
}
/**
@ -240,8 +240,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)
@ -272,18 +272,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;
}
@ -308,15 +308,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;
}
}
@ -350,6 +350,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;
@ -359,6 +594,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;
}

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