You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1831 lines
51 KiB
1831 lines
51 KiB
/**
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
*
|
|
* Copyright (C) Jay Sorg 2009-2014
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include <config_ac.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/errno.h>
|
|
#include <signal.h>
|
|
#include <sys/un.h>
|
|
|
|
#include "sound.h"
|
|
#include "thread_calls.h"
|
|
#include "defines.h"
|
|
#include "fifo.h"
|
|
#include "xrdp_constants.h"
|
|
#include "xrdp_sockets.h"
|
|
#include "chansrv_common.h"
|
|
|
|
#if defined(XRDP_FDK_AAC)
|
|
#include <fdk-aac/aacenc_lib.h>
|
|
static HANDLE_AACENCODER g_fdk_aac_encoder = 0;
|
|
|
|
#define AACENCODER_LIB_VER_GTEQ(vl0, vl1, vl2) \
|
|
(defined(AACENCODER_LIB_VL0) && \
|
|
((AACENCODER_LIB_VL0 > vl0) || \
|
|
(AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 >= vl1) || \
|
|
(AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 == vl1 && AACENCODER_LIB_VL2 > vl2)))
|
|
#endif
|
|
|
|
#if defined(XRDP_OPUS)
|
|
#include <opus/opus.h>
|
|
static OpusEncoder *g_opus_encoder = 0;
|
|
#endif
|
|
|
|
#if defined(XRDP_MP3LAME)
|
|
#include <lame/lame.h>
|
|
static lame_global_flags *g_lame_encoder = 0;
|
|
#endif
|
|
|
|
extern int g_rdpsnd_chan_id; /* in chansrv.c */
|
|
extern int g_display_num; /* in chansrv.c */
|
|
|
|
/* audio out: sound_server -> xrdp -> NeutrinoRDP */
|
|
static struct trans *g_audio_l_trans_out = 0; /* listener */
|
|
static struct trans *g_audio_c_trans_out = 0; /* connection */
|
|
|
|
/* audio in: sound_server <- xrdp <- NeutrinoRDP */
|
|
static struct trans *g_audio_l_trans_in = 0; /* listener */
|
|
static struct trans *g_audio_c_trans_in = 0; /* connection */
|
|
|
|
static int g_training_sent_time = 0;
|
|
static int g_cBlockNo = 0;
|
|
static int g_bytes_in_stream = 0;
|
|
static FIFO g_in_fifo;
|
|
static int g_bytes_in_fifo = 0;
|
|
static int g_unacked_frames = 0;
|
|
|
|
static struct stream *g_stream_inp = NULL;
|
|
static struct stream *g_stream_incoming_packet = NULL;
|
|
|
|
#define MAX_BBUF_SIZE (1024 * 16)
|
|
static char g_buffer[MAX_BBUF_SIZE];
|
|
static int g_buf_index = 0;
|
|
static int g_sent_time[256];
|
|
static int g_sent_flag[256];
|
|
|
|
static int g_bbuf_size = 1024 * 8; /* may change later */
|
|
|
|
struct xr_wave_format_ex
|
|
{
|
|
int wFormatTag;
|
|
int nChannels;
|
|
int nSamplesPerSec;
|
|
int nAvgBytesPerSec;
|
|
int nBlockAlign;
|
|
int wBitsPerSample;
|
|
int cbSize;
|
|
tui8 *data;
|
|
};
|
|
|
|
/* output formats */
|
|
|
|
static tui8 g_pcm_22050_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_pcm_22050 =
|
|
{
|
|
WAVE_FORMAT_PCM, /* wFormatTag */
|
|
2, /* num of channels */
|
|
22050, /* samples per sec */
|
|
88200, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_pcm_22050_data /* data */
|
|
};
|
|
|
|
static tui8 g_pcm_44100_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_pcm_44100 =
|
|
{
|
|
WAVE_FORMAT_PCM, /* wFormatTag */
|
|
2, /* num of channels */
|
|
44100, /* samples per sec */
|
|
176400, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_pcm_44100_data /* data */
|
|
};
|
|
|
|
#if defined(XRDP_FDK_AAC)
|
|
static tui8 g_fdk_aac_44100_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_fdk_aac_44100 =
|
|
{
|
|
WAVE_FORMAT_AAC, /* wFormatTag */
|
|
2, /* num of channels */
|
|
44100, /* samples per sec */
|
|
12000, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_fdk_aac_44100_data /* data */
|
|
};
|
|
#endif
|
|
|
|
#if defined(XRDP_OPUS)
|
|
static tui8 g_opus_44100_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_opus_44100 =
|
|
{
|
|
WAVE_FORMAT_OPUS, /* wFormatTag */
|
|
2, /* num of channels */
|
|
44100, /* samples per sec */
|
|
176400, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_opus_44100_data /* data */
|
|
};
|
|
#endif
|
|
|
|
#if defined(XRDP_MP3LAME)
|
|
static tui8 g_mp3lame_44100_data[] = { 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x01, 0x00, 0x71, 0x05 };
|
|
static struct xr_wave_format_ex g_mp3lame_44100 =
|
|
{
|
|
WAVE_FORMAT_MPEGLAYER3, /* wFormatTag */
|
|
2, /* num of channels */
|
|
44100, /* samples per sec */
|
|
176400, /* avg bytes per sec */
|
|
4, /* block align */
|
|
0, /* bits per sample */
|
|
12, /* data size */
|
|
g_mp3lame_44100_data /* data */
|
|
};
|
|
#endif
|
|
|
|
static struct xr_wave_format_ex *g_wave_outp_formats[] =
|
|
{
|
|
&g_pcm_44100,
|
|
&g_pcm_22050,
|
|
#if defined(XRDP_FDK_AAC)
|
|
&g_fdk_aac_44100,
|
|
#endif
|
|
#if defined(XRDP_OPUS)
|
|
&g_opus_44100,
|
|
#endif
|
|
#if defined(XRDP_MP3LAME)
|
|
&g_mp3lame_44100,
|
|
#endif
|
|
0
|
|
};
|
|
|
|
static int g_client_does_fdk_aac = 0;
|
|
static int g_client_fdk_aac_index = 0;
|
|
|
|
static int g_client_does_opus = 0;
|
|
static int g_client_opus_index = 0;
|
|
|
|
static int g_client_does_mp3lame = 0;
|
|
static int g_client_mp3lame_index = 0;
|
|
|
|
/* index into list from client */
|
|
static int g_current_client_format_index = 0;
|
|
|
|
/* index into list from server */
|
|
static int g_current_server_format_index = 0;
|
|
|
|
/* input formats */
|
|
|
|
static tui8 g_pcm_inp_22050_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_pcm_inp_22050 =
|
|
{
|
|
WAVE_FORMAT_PCM, /* wFormatTag */
|
|
2, /* num of channels */
|
|
22050, /* samples per sec */
|
|
88200, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_pcm_inp_22050_data /* data */
|
|
};
|
|
|
|
static tui8 g_pcm_inp_44100_data[] = { 0 };
|
|
static struct xr_wave_format_ex g_pcm_inp_44100 =
|
|
{
|
|
WAVE_FORMAT_PCM, /* wFormatTag */
|
|
2, /* num of channels */
|
|
44100, /* samples per sec */
|
|
176400, /* avg bytes per sec */
|
|
4, /* block align */
|
|
16, /* bits per sample */
|
|
0, /* data size */
|
|
g_pcm_inp_44100_data /* data */
|
|
};
|
|
|
|
static struct xr_wave_format_ex *g_wave_inp_formats[] =
|
|
{
|
|
&g_pcm_inp_44100,
|
|
&g_pcm_inp_22050,
|
|
0
|
|
};
|
|
|
|
static int g_client_input_format_index = 0;
|
|
static int g_server_input_format_index = 0;
|
|
|
|
/* microphone related */
|
|
static int sound_send_server_input_formats(void);
|
|
static int sound_process_input_format(int aindex, int wFormatTag,
|
|
int nChannels, int nSamplesPerSec,
|
|
int nAvgBytesPerSec, int nBlockAlign,
|
|
int wBitsPerSample, int cbSize, char *data);
|
|
static int sound_process_input_formats(struct stream *s, int size);
|
|
static int sound_input_start_recording(void);
|
|
static int sound_input_stop_recording(void);
|
|
static int sound_process_input_data(struct stream *s, int bytes);
|
|
static int sound_sndsrvr_source_data_in(struct trans *trans);
|
|
static int sound_start_source_listener(void);
|
|
static int sound_start_sink_listener(void);
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_send_server_output_formats(void)
|
|
{
|
|
struct stream *s;
|
|
int bytes;
|
|
int index;
|
|
int num_formats;
|
|
char *size_ptr;
|
|
|
|
num_formats = sizeof(g_wave_outp_formats) /
|
|
sizeof(g_wave_outp_formats[0]) - 1;
|
|
LOG(10, ("sound_send_server_output_formats: num_formats %d", num_formats));
|
|
|
|
make_stream(s);
|
|
init_stream(s, 8182);
|
|
out_uint16_le(s, SNDC_FORMATS);
|
|
size_ptr = s->p;
|
|
out_uint16_le(s, 0); /* size, set later */
|
|
out_uint32_le(s, 0); /* dwFlags */
|
|
out_uint32_le(s, 0); /* dwVolume */
|
|
out_uint32_le(s, 0); /* dwPitch */
|
|
out_uint16_le(s, 0); /* wDGramPort */
|
|
out_uint16_le(s, num_formats); /* wNumberOfFormats */
|
|
out_uint8(s, g_cBlockNo); /* cLastBlockConfirmed */
|
|
out_uint16_le(s, 5); /* wVersion */
|
|
out_uint8(s, 0); /* bPad */
|
|
|
|
/* sndFormats */
|
|
/*
|
|
wFormatTag 2 byte offset 0
|
|
nChannels 2 byte offset 2
|
|
nSamplesPerSec 4 byte offset 4
|
|
nAvgBytesPerSec 4 byte offset 8
|
|
nBlockAlign 2 byte offset 12
|
|
wBitsPerSample 2 byte offset 14
|
|
cbSize 2 byte offset 16
|
|
data variable offset 18
|
|
*/
|
|
|
|
/* examples
|
|
01 00 02 00 44 ac 00 00 10 b1 02 00 04 00 10 00 ....D...........
|
|
00 00
|
|
01 00 02 00 22 56 00 00 88 58 01 00 04 00 10 00 ...."V...X......
|
|
00 00
|
|
*/
|
|
|
|
for (index = 0; index < num_formats; index++)
|
|
{
|
|
out_uint16_le(s, g_wave_outp_formats[index]->wFormatTag);
|
|
out_uint16_le(s, g_wave_outp_formats[index]->nChannels);
|
|
out_uint32_le(s, g_wave_outp_formats[index]->nSamplesPerSec);
|
|
out_uint32_le(s, g_wave_outp_formats[index]->nAvgBytesPerSec);
|
|
out_uint16_le(s, g_wave_outp_formats[index]->nBlockAlign);
|
|
out_uint16_le(s, g_wave_outp_formats[index]->wBitsPerSample);
|
|
bytes = g_wave_outp_formats[index]->cbSize;
|
|
out_uint16_le(s, bytes);
|
|
if (bytes > 0)
|
|
{
|
|
out_uint8p(s, g_wave_outp_formats[index]->data, bytes);
|
|
}
|
|
}
|
|
|
|
s_mark_end(s);
|
|
bytes = (int)((s->end - s->data) - 4);
|
|
size_ptr[0] = bytes;
|
|
size_ptr[1] = bytes >> 8;
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
free_stream(s);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_send_training(void)
|
|
{
|
|
struct stream *s;
|
|
int bytes;
|
|
int time;
|
|
char *size_ptr;
|
|
|
|
make_stream(s);
|
|
init_stream(s, 8182);
|
|
out_uint16_le(s, SNDC_TRAINING);
|
|
size_ptr = s->p;
|
|
out_uint16_le(s, 0); /* size, set later */
|
|
time = g_time2();
|
|
g_training_sent_time = time;
|
|
out_uint16_le(s, time);
|
|
out_uint16_le(s, 1024);
|
|
out_uint8s(s, (1024 - 4));
|
|
s_mark_end(s);
|
|
bytes = (int)((s->end - s->data) - 4);
|
|
size_ptr[0] = bytes;
|
|
size_ptr[1] = bytes >> 8;
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
free_stream(s);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_process_output_format(int aindex, int wFormatTag, int nChannels,
|
|
int nSamplesPerSec, int nAvgBytesPerSec,
|
|
int nBlockAlign, int wBitsPerSample,
|
|
int cbSize, char *data)
|
|
{
|
|
LOG(1, ("sound_process_output_format:"));
|
|
LOG(1, (" wFormatTag %d", wFormatTag));
|
|
LOG(1, (" nChannels %d", nChannels));
|
|
LOG(1, (" nSamplesPerSec %d", nSamplesPerSec));
|
|
LOG(1, (" nAvgBytesPerSec %d", nAvgBytesPerSec));
|
|
LOG(1, (" nBlockAlign %d", nBlockAlign));
|
|
LOG(1, (" wBitsPerSample %d", wBitsPerSample));
|
|
LOG(1, (" cbSize %d", cbSize));
|
|
|
|
g_hexdump(data, cbSize);
|
|
|
|
/* select CD quality audio */
|
|
if (wFormatTag == g_pcm_44100.wFormatTag &&
|
|
nChannels == g_pcm_44100.nChannels &&
|
|
nSamplesPerSec == g_pcm_44100.nSamplesPerSec &&
|
|
nAvgBytesPerSec == g_pcm_44100.nAvgBytesPerSec &&
|
|
nBlockAlign == g_pcm_44100.nBlockAlign &&
|
|
wBitsPerSample == g_pcm_44100.wBitsPerSample)
|
|
{
|
|
g_current_client_format_index = aindex;
|
|
g_current_server_format_index = 0;
|
|
}
|
|
#if 0
|
|
for (lindex = 0; lindex < NUM_BUILT_IN; lindex++)
|
|
{
|
|
if (wFormatTag == g_wave_formats[lindex]->wFormatTag &&
|
|
nChannels == g_wave_formats[lindex]->nChannels &&
|
|
nSamplesPerSec == g_wave_formats[lindex]->nSamplesPerSec &&
|
|
nAvgBytesPerSec == g_wave_formats[lindex]->nAvgBytesPerSec &&
|
|
nBlockAlign == g_wave_formats[lindex]->nBlockAlign &&
|
|
wBitsPerSample == g_wave_formats[lindex]->wBitsPerSample)
|
|
{
|
|
g_current_client_format_index = aindex;
|
|
g_current_server_format_index = lindex;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
switch(wFormatTag)
|
|
{
|
|
case WAVE_FORMAT_AAC:
|
|
LOG(0, ("wFormatTag, fdk aac"));
|
|
g_client_does_fdk_aac = 1;
|
|
g_client_fdk_aac_index = aindex;
|
|
break;
|
|
case WAVE_FORMAT_MPEGLAYER3:
|
|
LOG(0, ("wFormatTag, mp3"));
|
|
g_client_does_mp3lame = 1;
|
|
g_client_mp3lame_index = aindex;
|
|
break;
|
|
case WAVE_FORMAT_OPUS:
|
|
LOG(0, ("wFormatTag, opus"));
|
|
g_client_does_opus = 1;
|
|
g_client_opus_index = aindex;
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
0000 07 02 26 00 03 00 80 00 ff ff ff ff 00 00 00 00 ..&.............
|
|
0010 00 00 01 00 00 02 00 00 01 00 02 00 44 ac 00 00 ............D...
|
|
0020 10 b1 02 00 04 00 10 00 00 00
|
|
*/
|
|
|
|
static int
|
|
sound_process_output_formats(struct stream *s, int size)
|
|
{
|
|
int num_formats;
|
|
int index;
|
|
int wFormatTag;
|
|
int nChannels;
|
|
int nSamplesPerSec;
|
|
int nAvgBytesPerSec;
|
|
int nBlockAlign;
|
|
int wBitsPerSample;
|
|
int cbSize;
|
|
char *data;
|
|
|
|
if (size < 16)
|
|
return 1;
|
|
|
|
in_uint8s(s, 14);
|
|
in_uint16_le(s, num_formats);
|
|
in_uint8s(s, 4);
|
|
|
|
if (num_formats > 0)
|
|
{
|
|
for (index = 0; index < num_formats; index++)
|
|
{
|
|
in_uint16_le(s, wFormatTag);
|
|
in_uint16_le(s, nChannels);
|
|
in_uint32_le(s, nSamplesPerSec);
|
|
in_uint32_le(s, nAvgBytesPerSec);
|
|
in_uint16_le(s, nBlockAlign);
|
|
in_uint16_le(s, wBitsPerSample);
|
|
in_uint16_le(s, cbSize);
|
|
in_uint8p(s, data, cbSize);
|
|
sound_process_output_format(index, wFormatTag, nChannels, nSamplesPerSec,
|
|
nAvgBytesPerSec, nBlockAlign, wBitsPerSample,
|
|
cbSize, data);
|
|
}
|
|
sound_send_training();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(XRDP_FDK_AAC)
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_fdk_aac(char *data, int data_bytes, int *format_index)
|
|
{
|
|
int rv;
|
|
int cdata_bytes;
|
|
char *cdata;
|
|
|
|
AACENC_ERROR error;
|
|
int aot;
|
|
int sample_rate;
|
|
int mode;
|
|
int bitrate;
|
|
int afterburner;
|
|
int channel_order;
|
|
AACENC_InfoStruct info;
|
|
AACENC_BufDesc in_buf;
|
|
AACENC_BufDesc out_buf;
|
|
AACENC_InArgs in_args;
|
|
AACENC_OutArgs out_args;
|
|
void *in_buffer;
|
|
int in_identifier;
|
|
int in_size;
|
|
int in_elem_size;
|
|
void *out_buffer;
|
|
int out_identifier;
|
|
int out_size;
|
|
int out_elem_size;
|
|
|
|
rv = data_bytes;
|
|
|
|
if (g_client_does_fdk_aac == 0)
|
|
{
|
|
return rv;
|
|
}
|
|
|
|
if (g_fdk_aac_encoder == 0)
|
|
{
|
|
/* init fdk aac encoder */
|
|
LOG(0, ("sound_wave_compress_fdk_aac: using fdk aac"));
|
|
|
|
error = aacEncOpen(&g_fdk_aac_encoder, 0, 2);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncOpen() failed"));
|
|
return rv;
|
|
}
|
|
|
|
aot = 2; /* MPEG-4 AAC Low Complexity. */
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_AOT, aot);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_AOT failed"));
|
|
}
|
|
|
|
sample_rate = g_fdk_aac_44100.nSamplesPerSec;
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_SAMPLERATE,
|
|
sample_rate);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_SAMPLERATE failed"));
|
|
}
|
|
|
|
mode = MODE_2;
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder,
|
|
AACENC_CHANNELMODE, mode);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_CHANNELMODE failed"));
|
|
}
|
|
|
|
channel_order = 1; /* WAVE file format channel ordering */
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_CHANNELORDER,
|
|
channel_order);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_CHANNELORDER failed"));
|
|
}
|
|
|
|
/* bytes rate to bit rate */
|
|
bitrate = g_fdk_aac_44100.nAvgBytesPerSec * 8;
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_BITRATE,
|
|
bitrate);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_BITRATE failed"));
|
|
}
|
|
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_TRANSMUX, 0);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_TRANSMUX failed"));
|
|
}
|
|
|
|
afterburner = 1;
|
|
error = aacEncoder_SetParam(g_fdk_aac_encoder, AACENC_AFTERBURNER,
|
|
afterburner);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncoder_SetParam() "
|
|
"AACENC_AFTERBURNER failed"));
|
|
}
|
|
|
|
error = aacEncEncode(g_fdk_aac_encoder, NULL, NULL, NULL, NULL);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: Unable to initialize "
|
|
"the encoder"));
|
|
}
|
|
|
|
g_memset(&info, 0, sizeof(info));
|
|
error = aacEncInfo(g_fdk_aac_encoder, &info);
|
|
if (error != AACENC_OK)
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncInfo failed"));
|
|
}
|
|
|
|
LOG(0, ("sound_wave_compress_fdk_aac:"));
|
|
LOG(0, (" AACENC_InfoStruct"));
|
|
LOG(0, (" maxOutBufBytes %d", info.maxOutBufBytes));
|
|
LOG(0, (" maxAncBytes %d", info.maxAncBytes));
|
|
LOG(0, (" inBufFillLevel %d", info.inBufFillLevel));
|
|
LOG(0, (" inputChannels %d", info.inputChannels));
|
|
LOG(0, (" frameLength %d", info.frameLength));
|
|
#if AACENCODER_LIB_VER_GTEQ(4, 0, 0)
|
|
LOG(0, (" nDelay %d", info.nDelay));
|
|
LOG(0, (" nDelayCore %d", info.nDelayCore));
|
|
#else
|
|
LOG(0, (" encoderDelay %d", info.encoderDelay));
|
|
#endif
|
|
LOG(0, (" confBuf"));
|
|
LOG(0, (" confSize %d", info.confSize));
|
|
}
|
|
|
|
rv = data_bytes;
|
|
cdata_bytes = data_bytes;
|
|
cdata = (char *) g_malloc(cdata_bytes, 0);
|
|
if (data_bytes < g_bbuf_size)
|
|
{
|
|
g_memset(data + data_bytes, 0, g_bbuf_size - data_bytes);
|
|
data_bytes = g_bbuf_size;
|
|
}
|
|
|
|
in_buffer = data;
|
|
in_identifier = IN_AUDIO_DATA;
|
|
in_size = data_bytes;
|
|
in_elem_size = 2;
|
|
|
|
g_memset(&in_args, 0, sizeof(in_args));
|
|
in_args.numInSamples = data_bytes / 2;
|
|
g_memset(&in_buf, 0, sizeof(in_buf));
|
|
in_buf.numBufs = 1;
|
|
in_buf.bufs = &in_buffer;
|
|
in_buf.bufferIdentifiers = &in_identifier;
|
|
in_buf.bufSizes = &in_size;
|
|
in_buf.bufElSizes = &in_elem_size;
|
|
|
|
out_buffer = cdata;
|
|
out_identifier = OUT_BITSTREAM_DATA;
|
|
out_size = cdata_bytes;
|
|
out_elem_size = 1;
|
|
|
|
g_memset(&out_buf, 0, sizeof(out_buf));
|
|
out_buf.numBufs = 1;
|
|
out_buf.bufs = &out_buffer;
|
|
out_buf.bufferIdentifiers = &out_identifier;
|
|
out_buf.bufSizes = &out_size;
|
|
out_buf.bufElSizes = &out_elem_size;
|
|
|
|
g_memset(&out_args, 0, sizeof(out_args));
|
|
error = aacEncEncode(g_fdk_aac_encoder, &in_buf, &out_buf,
|
|
&in_args, &out_args);
|
|
if (error == AACENC_OK)
|
|
{
|
|
cdata_bytes = out_args.numOutBytes;
|
|
LOG(10, ("sound_wave_compress_fdk_aac: aacEncEncode ok "
|
|
"cdata_bytes %d", cdata_bytes));
|
|
*format_index = g_client_fdk_aac_index;
|
|
g_memcpy(data, cdata, cdata_bytes);
|
|
rv = cdata_bytes;
|
|
}
|
|
else
|
|
{
|
|
LOG(0, ("sound_wave_compress_fdk_aac: aacEncEncode failed"));
|
|
}
|
|
g_free(cdata);
|
|
|
|
return rv;
|
|
}
|
|
|
|
#else
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_fdk_aac(char *data, int data_bytes, int *format_index)
|
|
{
|
|
return data_bytes;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(XRDP_OPUS)
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_opus(char *data, int data_bytes, int *format_index)
|
|
{
|
|
unsigned char *cdata;
|
|
int cdata_bytes;
|
|
int rv;
|
|
int error;
|
|
int data_bytes_org;
|
|
opus_int16 *os16;
|
|
|
|
if (g_client_does_opus == 0)
|
|
{
|
|
return data_bytes;
|
|
}
|
|
if (g_opus_encoder == 0)
|
|
{
|
|
/* NB (narrowband) 8 kHz
|
|
MB (medium-band) 12 kHz
|
|
WB (wideband) 16 kHz
|
|
SWB (super-wideband) 24 kHz
|
|
FB (fullband) 48 kHz */
|
|
g_opus_encoder = opus_encoder_create(48000, 2,
|
|
OPUS_APPLICATION_AUDIO,
|
|
&error);
|
|
if (g_opus_encoder == 0)
|
|
{
|
|
LOG(0, ("sound_wave_compress_opus: opus_encoder_create failed"));
|
|
return data_bytes;
|
|
}
|
|
}
|
|
data_bytes_org = data_bytes;
|
|
rv = data_bytes;
|
|
cdata_bytes = data_bytes;
|
|
cdata = (unsigned char *) g_malloc(cdata_bytes, 0);
|
|
os16 = (opus_int16 *) data;
|
|
/* at 48000 we have
|
|
2.5 ms 480
|
|
5 ms 960
|
|
10 ms 1920
|
|
20 ms 3840
|
|
40 ms 7680
|
|
60 ms 11520 */
|
|
if (data_bytes < g_bbuf_size)
|
|
{
|
|
g_memset(data + data_bytes, 0, g_bbuf_size - data_bytes);
|
|
data_bytes = g_bbuf_size;
|
|
}
|
|
cdata_bytes = opus_encode(g_opus_encoder, os16, data_bytes / 4,
|
|
cdata, cdata_bytes);
|
|
if ((cdata_bytes > 0) && (cdata_bytes < data_bytes_org))
|
|
{
|
|
*format_index = g_client_opus_index;
|
|
g_memcpy(data, cdata, cdata_bytes);
|
|
rv = cdata_bytes;
|
|
}
|
|
g_free(cdata);
|
|
return rv;
|
|
}
|
|
|
|
#else
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_opus(char *data, int data_bytes, int *format_index)
|
|
{
|
|
return data_bytes;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(XRDP_MP3LAME)
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_mp3lame(char *data, int data_bytes, int *format_index)
|
|
{
|
|
int rv;
|
|
int cdata_bytes;
|
|
int odata_bytes;
|
|
unsigned char *cdata;
|
|
|
|
cdata = NULL;
|
|
rv = data_bytes;
|
|
|
|
if (g_client_does_mp3lame == 0)
|
|
{
|
|
return rv;
|
|
}
|
|
|
|
if (g_lame_encoder == 0)
|
|
{
|
|
/* init mp3 lame encoder */
|
|
LOG(0, ("sound_wave_compress_mp3lame: using mp3lame"));
|
|
|
|
g_lame_encoder = lame_init();
|
|
if (g_lame_encoder == 0)
|
|
{
|
|
LOG(0, ("sound_wave_compress_mp3lame: lame_init() failed"));
|
|
return rv;
|
|
}
|
|
lame_set_num_channels(g_lame_encoder, g_mp3lame_44100.nChannels);
|
|
lame_set_in_samplerate(g_lame_encoder, g_mp3lame_44100.nSamplesPerSec);
|
|
if (lame_init_params(g_lame_encoder) == -1)
|
|
{
|
|
LOG(0, ("sound_wave_compress_mp3lame: lame_init_params() failed"));
|
|
return rv;
|
|
}
|
|
|
|
LOG(0, ("sound_wave_compress_mp3lame: lame config:"));
|
|
LOG(0, (" brate : %d", lame_get_brate(g_lame_encoder)));
|
|
LOG(0, (" compression ratio: %f", lame_get_compression_ratio(g_lame_encoder)));
|
|
LOG(0, (" encoder delay : %d", lame_get_encoder_delay(g_lame_encoder)));
|
|
LOG(0, (" frame size : %d", lame_get_framesize(g_lame_encoder)));
|
|
LOG(0, (" encoder padding : %d", lame_get_encoder_padding(g_lame_encoder)));
|
|
LOG(0, (" mode : %d", lame_get_mode(g_lame_encoder)));
|
|
}
|
|
|
|
odata_bytes = data_bytes;
|
|
cdata_bytes = data_bytes;
|
|
cdata = (unsigned char *) g_malloc(cdata_bytes, 0);
|
|
if (data_bytes < g_bbuf_size)
|
|
{
|
|
g_memset(data + data_bytes, 0, g_bbuf_size - data_bytes);
|
|
data_bytes = g_bbuf_size;
|
|
}
|
|
cdata_bytes = lame_encode_buffer_interleaved(g_lame_encoder,
|
|
(short int *) data,
|
|
data_bytes / 4,
|
|
cdata,
|
|
cdata_bytes);
|
|
if (cdata_bytes < 0)
|
|
{
|
|
LOG(0, ("sound_wave_compress: lame_encode_buffer_interleaved() "
|
|
"failed, error %d", cdata_bytes));
|
|
return rv;
|
|
}
|
|
if ((cdata_bytes > 0) && (cdata_bytes < odata_bytes))
|
|
{
|
|
*format_index = g_client_mp3lame_index;
|
|
g_memcpy(data, cdata, cdata_bytes);
|
|
rv = cdata_bytes;
|
|
}
|
|
|
|
g_free(cdata);
|
|
return rv;
|
|
}
|
|
|
|
#else
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress_mp3lame(char *data, int data_bytes, int *format_index)
|
|
{
|
|
return data_bytes;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
static int
|
|
sound_wave_compress(char *data, int data_bytes, int *format_index)
|
|
{
|
|
if (g_client_does_fdk_aac)
|
|
{
|
|
g_bbuf_size = 4096;
|
|
return sound_wave_compress_fdk_aac(data, data_bytes, format_index);
|
|
}
|
|
else if (g_client_does_opus)
|
|
{
|
|
g_bbuf_size = 11520;
|
|
return sound_wave_compress_opus(data, data_bytes, format_index);
|
|
}
|
|
else if (g_client_does_mp3lame)
|
|
{
|
|
g_bbuf_size = 11520;
|
|
return sound_wave_compress_mp3lame(data, data_bytes, format_index);
|
|
}
|
|
return data_bytes;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* send wave message to client */
|
|
static int
|
|
sound_send_wave_data_chunk(char *data, int data_bytes)
|
|
{
|
|
struct stream *s;
|
|
int bytes;
|
|
int time;
|
|
int format_index;
|
|
char *size_ptr;
|
|
|
|
LOG(10, ("sound_send_wave_data_chunk: data_bytes %d", data_bytes));
|
|
|
|
if ((data_bytes < 4) || (data_bytes > 128 * 1024))
|
|
{
|
|
LOG(0, ("sound_send_wave_data_chunk: bad data_bytes %d", data_bytes));
|
|
return 1;
|
|
}
|
|
|
|
LOG(20, ("sound_send_wave_data_chunk: g_sent_flag[%d] = %d",
|
|
g_cBlockNo + 1, g_sent_flag[(g_cBlockNo + 1) & 0xff]));
|
|
if (g_sent_flag[(g_cBlockNo + 1) & 0xff] & 1)
|
|
{
|
|
LOG(10, ("sound_send_wave_data_chunk: no room"));
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
LOG(10, ("sound_send_wave_data_chunk: got room"));
|
|
}
|
|
|
|
/* compress, if available */
|
|
format_index = g_current_client_format_index;
|
|
data_bytes = sound_wave_compress(data, data_bytes, &format_index);
|
|
|
|
/* part one of 2 PDU wave info */
|
|
|
|
LOG(10, ("sound_send_wave_data_chunk: sending %d bytes", data_bytes));
|
|
|
|
make_stream(s);
|
|
init_stream(s, 16 + data_bytes); /* some extra space */
|
|
out_uint16_le(s, SNDC_WAVE);
|
|
size_ptr = s->p;
|
|
out_uint16_le(s, 0); /* size, set later */
|
|
time = g_time2();
|
|
out_uint16_le(s, time);
|
|
out_uint16_le(s, format_index); /* wFormatNo */
|
|
g_cBlockNo++;
|
|
g_unacked_frames++;
|
|
out_uint8(s, g_cBlockNo);
|
|
g_sent_time[g_cBlockNo & 0xff] = time;
|
|
g_sent_flag[g_cBlockNo & 0xff] = 1;
|
|
|
|
LOG(10, ("sound_send_wave_data_chunk: sending time %d, g_cBlockNo %d",
|
|
time & 0xffff, g_cBlockNo & 0xff));
|
|
|
|
out_uint8s(s, 3);
|
|
out_uint8a(s, data, 4);
|
|
s_mark_end(s);
|
|
bytes = (int)((s->end - s->data) - 4);
|
|
bytes += data_bytes;
|
|
bytes -= 4;
|
|
size_ptr[0] = bytes;
|
|
size_ptr[1] = bytes >> 8;
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
|
|
/* part two of 2 PDU wave info
|
|
even is zero, we have to send this */
|
|
init_stream(s, data_bytes);
|
|
out_uint32_le(s, 0);
|
|
out_uint8a(s, data + 4, data_bytes - 4);
|
|
s_mark_end(s);
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
|
|
free_stream(s);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* send wave message to client, buffer first */
|
|
static int
|
|
sound_send_wave_data(char *data, int data_bytes)
|
|
{
|
|
int space_left;
|
|
int chunk_bytes;
|
|
int data_index;
|
|
int error;
|
|
int res;
|
|
|
|
LOG(10, ("sound_send_wave_data: sending %d bytes", data_bytes));
|
|
data_index = 0;
|
|
error = 0;
|
|
while (data_bytes > 0)
|
|
{
|
|
space_left = g_bbuf_size - g_buf_index;
|
|
chunk_bytes = MIN(space_left, data_bytes);
|
|
if (chunk_bytes < 1)
|
|
{
|
|
LOG(10, ("sound_send_wave_data: error"));
|
|
error = 1;
|
|
break;
|
|
}
|
|
g_memcpy(g_buffer + g_buf_index, data + data_index, chunk_bytes);
|
|
g_buf_index += chunk_bytes;
|
|
if (g_buf_index >= g_bbuf_size)
|
|
{
|
|
g_buf_index = 0;
|
|
res = sound_send_wave_data_chunk(g_buffer, g_bbuf_size);
|
|
if (res == 2)
|
|
{
|
|
/* don't need to error on this */
|
|
LOG(0, ("sound_send_wave_data: dropped, no room"));
|
|
break;
|
|
}
|
|
else if (res != 0)
|
|
{
|
|
LOG(10, ("sound_send_wave_data: error"));
|
|
error = 1;
|
|
break;
|
|
}
|
|
}
|
|
data_bytes -= chunk_bytes;
|
|
data_index += chunk_bytes;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* send close message to client */
|
|
static int
|
|
sound_send_close(void)
|
|
{
|
|
struct stream *s;
|
|
int bytes;
|
|
char *size_ptr;
|
|
|
|
LOG(10, ("sound_send_close:"));
|
|
|
|
/* send any left over data */
|
|
if (g_buf_index)
|
|
{
|
|
if (sound_send_wave_data_chunk(g_buffer, g_buf_index) != 0)
|
|
{
|
|
LOG(10, ("sound_send_close: sound_send_wave_data_chunk failed"));
|
|
return 1;
|
|
}
|
|
}
|
|
g_buf_index = 0;
|
|
g_memset(g_sent_flag, 0, sizeof(g_sent_flag));
|
|
|
|
/* send close msg */
|
|
make_stream(s);
|
|
init_stream(s, 8182);
|
|
out_uint16_le(s, SNDC_CLOSE);
|
|
size_ptr = s->p;
|
|
out_uint16_le(s, 0); /* size, set later */
|
|
s_mark_end(s);
|
|
bytes = (int)((s->end - s->data) - 4);
|
|
size_ptr[0] = bytes;
|
|
size_ptr[1] = bytes >> 8;
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
free_stream(s);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* from client */
|
|
static int
|
|
sound_process_training(struct stream *s, int size)
|
|
{
|
|
int time_diff;
|
|
|
|
time_diff = g_time2() - g_training_sent_time;
|
|
LOG(0, ("sound_process_training: round trip time %u", time_diff));
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* from client */
|
|
static int
|
|
sound_process_wave_confirm(struct stream *s, int size)
|
|
{
|
|
int wTimeStamp;
|
|
int cConfirmedBlockNo;
|
|
int cleared_count;
|
|
int time;
|
|
int time_diff;
|
|
int block_no;
|
|
int block_no_clamped;
|
|
int found;
|
|
int index;
|
|
|
|
time = g_time2();
|
|
in_uint16_le(s, wTimeStamp);
|
|
in_uint8(s, cConfirmedBlockNo);
|
|
time_diff = time - g_sent_time[cConfirmedBlockNo & 0xff];
|
|
cleared_count = 0;
|
|
found = 0;
|
|
block_no = g_cBlockNo;
|
|
for (index = 0; index < g_unacked_frames; index++)
|
|
{
|
|
block_no_clamped = block_no & 0xff;
|
|
if ((cConfirmedBlockNo == block_no_clamped) || found)
|
|
{
|
|
found = 1;
|
|
if (g_sent_flag[block_no_clamped] & 1)
|
|
{
|
|
LOG(10, ("sound_process_wave_confirm: clearing %d",
|
|
block_no_clamped));
|
|
g_sent_flag[block_no_clamped] &= ~1;
|
|
cleared_count++;
|
|
}
|
|
}
|
|
block_no--;
|
|
}
|
|
LOG(10, ("sound_process_wave_confirm: wTimeStamp %d, "
|
|
"cConfirmedBlockNo %d time diff %d cleared_count %d "
|
|
"g_unacked_frames %d", wTimeStamp, cConfirmedBlockNo, time_diff,
|
|
cleared_count, g_unacked_frames));
|
|
g_unacked_frames -= cleared_count;
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* process message in from the audio source, eg pulse, alsa
|
|
on it's way to the client. returns error */
|
|
static int
|
|
process_pcm_message(int id, int size, struct stream *s)
|
|
{
|
|
switch (id)
|
|
{
|
|
case 0:
|
|
return sound_send_wave_data(s->p, size);
|
|
break;
|
|
case 1:
|
|
return sound_send_close();
|
|
break;
|
|
default:
|
|
LOG(10, ("process_pcm_message: unknown id %d", id));
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* data in from sound_server_sink */
|
|
|
|
static int
|
|
sound_sndsrvr_sink_data_in(struct trans *trans)
|
|
{
|
|
struct stream *s;
|
|
int id;
|
|
int size;
|
|
int error;
|
|
|
|
if (trans == 0)
|
|
return 0;
|
|
|
|
if (trans != g_audio_c_trans_out)
|
|
return 1;
|
|
|
|
s = trans_get_in_s(trans);
|
|
in_uint32_le(s, id);
|
|
in_uint32_le(s, size);
|
|
|
|
if ((id & ~3) || (size > 128 * 1024 + 8) || (size < 8))
|
|
{
|
|
LOG(0, ("sound_sndsrvr_sink_data_in: bad message id %d size %d", id, size));
|
|
return 1;
|
|
}
|
|
|
|
LOG(10, ("sound_sndsrvr_sink_data_in: good message id %d size %d", id, size));
|
|
|
|
error = trans_force_read(trans, size - 8);
|
|
|
|
if (error == 0)
|
|
{
|
|
/* here, the entire message block is read in, process it */
|
|
error = process_pcm_message(id, size - 8, s);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* incoming connection on unix domain socket - sound_server_sink -> xrdp */
|
|
|
|
static int
|
|
sound_sndsrvr_sink_conn_in(struct trans *trans, struct trans *new_trans)
|
|
{
|
|
LOG(0, ("sound_sndsrvr_sink_conn_in:"));
|
|
|
|
if (trans == 0)
|
|
return 1;
|
|
|
|
if (trans != g_audio_l_trans_out)
|
|
return 1;
|
|
|
|
if (g_audio_c_trans_out != 0) /* if already set, error */
|
|
return 1;
|
|
|
|
if (new_trans == 0)
|
|
return 1;
|
|
|
|
g_audio_c_trans_out = new_trans;
|
|
g_audio_c_trans_out->trans_data_in = sound_sndsrvr_sink_data_in;
|
|
g_audio_c_trans_out->header_size = 8;
|
|
trans_delete(g_audio_l_trans_out);
|
|
g_audio_l_trans_out = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* incoming connection on unix domain socket - sound_server_source -> xrdp */
|
|
|
|
static int
|
|
sound_sndsrvr_source_conn_in(struct trans *trans, struct trans *new_trans)
|
|
{
|
|
LOG(0, ("sound_sndsrvr_source_conn_in: client connected"));
|
|
|
|
if (trans == 0)
|
|
return 1;
|
|
|
|
if (trans != g_audio_l_trans_in)
|
|
return 1;
|
|
|
|
if (g_audio_c_trans_in != 0) /* if already set, error */
|
|
return 1;
|
|
|
|
if (new_trans == 0)
|
|
return 1;
|
|
|
|
g_audio_c_trans_in = new_trans;
|
|
g_audio_c_trans_in->trans_data_in = sound_sndsrvr_source_data_in;
|
|
g_audio_c_trans_in->header_size = 8;
|
|
trans_delete(g_audio_l_trans_in);
|
|
g_audio_l_trans_in = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
sound_init(void)
|
|
{
|
|
LOG(0, ("sound_init:"));
|
|
|
|
g_memset(g_sent_flag, 0, sizeof(g_sent_flag));
|
|
g_stream_incoming_packet = NULL;
|
|
|
|
/* init sound output */
|
|
sound_send_server_output_formats();
|
|
sound_start_sink_listener();
|
|
|
|
/* init sound input */
|
|
sound_send_server_input_formats();
|
|
sound_start_source_listener();
|
|
|
|
/* save data from sound_server_source */
|
|
fifo_init(&g_in_fifo, 100);
|
|
|
|
g_client_does_fdk_aac = 0;
|
|
g_client_fdk_aac_index = 0;
|
|
|
|
g_client_does_opus = 0;
|
|
g_client_opus_index = 0;
|
|
|
|
g_client_does_mp3lame = 0;
|
|
g_client_mp3lame_index = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
sound_deinit(void)
|
|
{
|
|
LOG(10, ("sound_deinit:"));
|
|
if (g_audio_l_trans_out != 0)
|
|
{
|
|
trans_delete(g_audio_l_trans_out);
|
|
g_audio_l_trans_out = 0;
|
|
}
|
|
|
|
if (g_audio_c_trans_out != 0)
|
|
{
|
|
trans_delete(g_audio_c_trans_out);
|
|
g_audio_c_trans_out = 0;
|
|
}
|
|
|
|
if (g_audio_l_trans_in != 0)
|
|
{
|
|
trans_delete(g_audio_l_trans_in);
|
|
g_audio_l_trans_in = 0;
|
|
}
|
|
|
|
if (g_audio_c_trans_in != 0)
|
|
{
|
|
trans_delete(g_audio_c_trans_in);
|
|
g_audio_c_trans_in = 0;
|
|
}
|
|
|
|
#if defined(XRDP_MP3LAME)
|
|
if (g_lame_encoder)
|
|
{
|
|
lame_close(g_lame_encoder);
|
|
g_lame_encoder = 0;
|
|
g_client_does_mp3lame = 0;
|
|
}
|
|
#endif
|
|
|
|
fifo_deinit(&g_in_fifo);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* data in from client ( client -> xrdp -> chansrv ) */
|
|
|
|
int
|
|
sound_data_in(struct stream *s, int chan_id, int chan_flags, int length,
|
|
int total_length)
|
|
{
|
|
int code;
|
|
int size;
|
|
int ok_to_free = 1;
|
|
|
|
if (!read_entire_packet(s, &g_stream_incoming_packet, chan_flags,
|
|
length, total_length))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
in_uint8(g_stream_incoming_packet, code);
|
|
in_uint8s(g_stream_incoming_packet, 1);
|
|
in_uint16_le(g_stream_incoming_packet, size);
|
|
|
|
switch (code)
|
|
{
|
|
case SNDC_WAVECONFIRM:
|
|
sound_process_wave_confirm(g_stream_incoming_packet, size);
|
|
break;
|
|
|
|
case SNDC_TRAINING:
|
|
sound_process_training(g_stream_incoming_packet, size);
|
|
break;
|
|
|
|
case SNDC_FORMATS:
|
|
sound_process_output_formats(g_stream_incoming_packet, size);
|
|
break;
|
|
|
|
case SNDC_REC_NEGOTIATE:
|
|
sound_process_input_formats(g_stream_incoming_packet, size);
|
|
break;
|
|
|
|
case SNDC_REC_DATA:
|
|
sound_process_input_data(g_stream_incoming_packet, size);
|
|
ok_to_free = 0;
|
|
break;
|
|
|
|
default:
|
|
LOG(10, ("sound_data_in: unknown code %d size %d", code, size));
|
|
break;
|
|
}
|
|
|
|
if (ok_to_free && g_stream_incoming_packet)
|
|
{
|
|
xstream_free(g_stream_incoming_packet);
|
|
g_stream_incoming_packet = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
sound_get_wait_objs(tbus *objs, int *count, int *timeout)
|
|
{
|
|
int lcount;
|
|
|
|
lcount = *count;
|
|
|
|
if (g_audio_l_trans_out != 0)
|
|
{
|
|
objs[lcount] = g_audio_l_trans_out->sck;
|
|
lcount++;
|
|
}
|
|
|
|
if (g_audio_c_trans_out != 0)
|
|
{
|
|
objs[lcount] = g_audio_c_trans_out->sck;
|
|
lcount++;
|
|
}
|
|
|
|
if (g_audio_l_trans_in != 0)
|
|
{
|
|
objs[lcount] = g_audio_l_trans_in->sck;
|
|
lcount++;
|
|
}
|
|
|
|
if (g_audio_c_trans_in != 0)
|
|
{
|
|
objs[lcount] = g_audio_c_trans_in->sck;
|
|
lcount++;
|
|
}
|
|
|
|
*count = lcount;
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int
|
|
sound_check_wait_objs(void)
|
|
{
|
|
if (g_audio_l_trans_out != 0)
|
|
{
|
|
if (trans_check_wait_objs(g_audio_l_trans_out) != 0)
|
|
{
|
|
LOG(10, ("sound_check_wait_objs: g_audio_l_trans_out returned non-zero"));
|
|
trans_delete(g_audio_l_trans_out);
|
|
g_audio_l_trans_out = 0;
|
|
}
|
|
}
|
|
|
|
if (g_audio_c_trans_out != 0)
|
|
{
|
|
if (trans_check_wait_objs(g_audio_c_trans_out) != 0)
|
|
{
|
|
LOG(10, ("sound_check_wait_objs: g_audio_c_trans_out returned non-zero"));
|
|
trans_delete(g_audio_c_trans_out);
|
|
g_audio_c_trans_out = 0;
|
|
sound_start_sink_listener();
|
|
}
|
|
}
|
|
|
|
if (g_audio_l_trans_in != 0)
|
|
{
|
|
if (trans_check_wait_objs(g_audio_l_trans_in) != 0)
|
|
{
|
|
LOG(10, ("sound_check_wait_objs: g_audio_l_trans_in returned non-zero"));
|
|
trans_delete(g_audio_l_trans_in);
|
|
g_audio_l_trans_in = 0;
|
|
}
|
|
}
|
|
|
|
if (g_audio_c_trans_in != 0)
|
|
{
|
|
if (trans_check_wait_objs(g_audio_c_trans_in) != 0)
|
|
{
|
|
LOG(10, ("sound_check_wait_objs: g_audio_c_trans_in returned non-zero"));
|
|
trans_delete(g_audio_c_trans_in);
|
|
g_audio_c_trans_in = 0;
|
|
sound_start_source_listener();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************
|
|
** **
|
|
** Microphone related code **
|
|
** **
|
|
******************************************************************************/
|
|
|
|
/**
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_send_server_input_formats(void)
|
|
{
|
|
struct stream *s;
|
|
int bytes;
|
|
int index;
|
|
int num_formats;
|
|
char *size_ptr;
|
|
|
|
num_formats = sizeof(g_wave_inp_formats) /
|
|
sizeof(g_wave_inp_formats[0]) - 1;
|
|
LOG(10, ("sound_send_server_input_formats: num_formats %d", num_formats));
|
|
|
|
make_stream(s);
|
|
init_stream(s, 8182);
|
|
out_uint16_le(s, SNDC_REC_NEGOTIATE);
|
|
size_ptr = s->p;
|
|
out_uint16_le(s, 0); /* size, set later */
|
|
out_uint32_le(s, 0); /* unused */
|
|
out_uint32_le(s, 0); /* unused */
|
|
out_uint16_le(s, num_formats); /* wNumberOfFormats */
|
|
out_uint16_le(s, 5); /* wVersion */
|
|
|
|
/*
|
|
wFormatTag 2 byte offset 0
|
|
nChannels 2 byte offset 2
|
|
nSamplesPerSec 4 byte offset 4
|
|
nAvgBytesPerSec 4 byte offset 8
|
|
nBlockAlign 2 byte offset 12
|
|
wBitsPerSample 2 byte offset 14
|
|
cbSize 2 byte offset 16
|
|
data variable offset 18
|
|
*/
|
|
|
|
for (index = 0; index < num_formats; index++)
|
|
{
|
|
out_uint16_le(s, g_wave_inp_formats[index]->wFormatTag);
|
|
out_uint16_le(s, g_wave_inp_formats[index]->nChannels);
|
|
out_uint32_le(s, g_wave_inp_formats[index]->nSamplesPerSec);
|
|
out_uint32_le(s, g_wave_inp_formats[index]->nAvgBytesPerSec);
|
|
out_uint16_le(s, g_wave_inp_formats[index]->nBlockAlign);
|
|
out_uint16_le(s, g_wave_inp_formats[index]->wBitsPerSample);
|
|
bytes = g_wave_inp_formats[index]->cbSize;
|
|
out_uint16_le(s, bytes);
|
|
if (bytes > 0)
|
|
{
|
|
out_uint8p(s, g_wave_inp_formats[index]->data, bytes);
|
|
}
|
|
}
|
|
|
|
s_mark_end(s);
|
|
bytes = (int)((s->end - s->data) - 4);
|
|
size_ptr[0] = bytes;
|
|
size_ptr[1] = bytes >> 8;
|
|
bytes = (int)(s->end - s->data);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, bytes);
|
|
free_stream(s);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_process_input_format(int aindex, int wFormatTag, int nChannels,
|
|
int nSamplesPerSec, int nAvgBytesPerSec,
|
|
int nBlockAlign, int wBitsPerSample,
|
|
int cbSize, char *data)
|
|
{
|
|
LOG(10, ("sound_process_input_format:"));
|
|
LOG(10, (" wFormatTag %d", wFormatTag));
|
|
LOG(10, (" nChannels %d", nChannels));
|
|
LOG(10, (" nSamplesPerSec %d", nSamplesPerSec));
|
|
LOG(10, (" nAvgBytesPerSec %d", nAvgBytesPerSec));
|
|
LOG(10, (" nBlockAlign %d", nBlockAlign));
|
|
LOG(10, (" wBitsPerSample %d", wBitsPerSample));
|
|
LOG(10, (" cbSize %d", cbSize));
|
|
|
|
#if 1
|
|
/* select CD quality audio */
|
|
if (wFormatTag == g_pcm_inp_44100.wFormatTag &&
|
|
nChannels == g_pcm_inp_44100.nChannels &&
|
|
nSamplesPerSec == g_pcm_inp_44100.nSamplesPerSec &&
|
|
nAvgBytesPerSec == g_pcm_inp_44100.nAvgBytesPerSec &&
|
|
nBlockAlign == g_pcm_inp_44100.nBlockAlign &&
|
|
wBitsPerSample == g_pcm_inp_44100.wBitsPerSample)
|
|
{
|
|
g_client_input_format_index = aindex;
|
|
g_server_input_format_index = 0;
|
|
}
|
|
#else
|
|
/* select half of CD quality audio */
|
|
if (wFormatTag == g_pcm_inp_22050.wFormatTag &&
|
|
nChannels == g_pcm_inp_22050.nChannels &&
|
|
nSamplesPerSec == g_pcm_inp_22050.nSamplesPerSec &&
|
|
nAvgBytesPerSec == g_pcm_inp_22050.nAvgBytesPerSec &&
|
|
nBlockAlign == g_pcm_inp_22050.nBlockAlign &&
|
|
wBitsPerSample == g_pcm_inp_22050.wBitsPerSample)
|
|
{
|
|
g_client_input_format_index = aindex;
|
|
g_server_input_format_index = 0;
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_process_input_formats(struct stream *s, int size)
|
|
{
|
|
int num_formats;
|
|
int index;
|
|
int wFormatTag;
|
|
int nChannels;
|
|
int nSamplesPerSec;
|
|
int nAvgBytesPerSec;
|
|
int nBlockAlign;
|
|
int wBitsPerSample;
|
|
int cbSize;
|
|
char *data;
|
|
|
|
LOG(10, ("sound_process_input_formats: size=%d", size));
|
|
|
|
in_uint8s(s, 8); /* skip 8 bytes */
|
|
in_uint16_le(s, num_formats);
|
|
in_uint8s(s, 2); /* skip version */
|
|
|
|
if (num_formats > 0)
|
|
{
|
|
for (index = 0; index < num_formats; index++)
|
|
{
|
|
in_uint16_le(s, wFormatTag);
|
|
in_uint16_le(s, nChannels);
|
|
in_uint32_le(s, nSamplesPerSec);
|
|
in_uint32_le(s, nAvgBytesPerSec);
|
|
in_uint16_le(s, nBlockAlign);
|
|
in_uint16_le(s, wBitsPerSample);
|
|
in_uint16_le(s, cbSize);
|
|
in_uint8p(s, data, cbSize);
|
|
sound_process_input_format(index, wFormatTag, nChannels, nSamplesPerSec,
|
|
nAvgBytesPerSec, nBlockAlign, wBitsPerSample,
|
|
cbSize, data);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_input_start_recording(void)
|
|
{
|
|
struct stream* s;
|
|
|
|
LOG(10, ("sound_input_start_recording:"));
|
|
|
|
/* if there is any data in FIFO, discard it */
|
|
while ((s = (struct stream *) fifo_remove(&g_in_fifo)) != NULL)
|
|
{
|
|
xstream_free(s);
|
|
}
|
|
g_bytes_in_fifo = 0;
|
|
|
|
xstream_new(s, 1024);
|
|
|
|
/*
|
|
* command format
|
|
*
|
|
* 02 bytes command SNDC_REC_START
|
|
* 02 bytes length
|
|
* 02 bytes data format received earlier
|
|
*/
|
|
|
|
out_uint16_le(s, SNDC_REC_START);
|
|
out_uint16_le(s, 2);
|
|
out_uint16_le(s, g_client_input_format_index);
|
|
|
|
s_mark_end(s);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, 6);
|
|
xstream_free(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_input_stop_recording(void)
|
|
{
|
|
struct stream* s;
|
|
|
|
LOG(10, ("sound_input_stop_recording:"));
|
|
|
|
xstream_new(s, 1024);
|
|
|
|
/*
|
|
* command format
|
|
*
|
|
* 02 bytes command SNDC_REC_STOP
|
|
* 02 bytes length (zero)
|
|
*/
|
|
|
|
out_uint16_le(s, SNDC_REC_STOP);
|
|
out_uint16_le(s, 0);
|
|
|
|
s_mark_end(s);
|
|
send_channel_data(g_rdpsnd_chan_id, s->data, 4);
|
|
xstream_free(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Process data: xrdp <- client
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_process_input_data(struct stream *s, int bytes)
|
|
{
|
|
struct stream *ls;
|
|
|
|
LOG(10, ("sound_process_input_data: bytes %d g_bytes_in_fifo %d",
|
|
bytes, g_bytes_in_fifo));
|
|
#if 0 /* no need to cap anymore */
|
|
/* cap data in fifo */
|
|
if (g_bytes_in_fifo > 8 * 1024)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
xstream_new(ls, bytes);
|
|
g_memcpy(ls->data, s->p, bytes);
|
|
ls->p += bytes;
|
|
s_mark_end(ls);
|
|
fifo_insert(&g_in_fifo, (void *) ls);
|
|
g_bytes_in_fifo += bytes;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Got a command from sound_server_source
|
|
*****************************************************************************/
|
|
|
|
static int
|
|
sound_sndsrvr_source_data_in(struct trans *trans)
|
|
{
|
|
struct stream *ts = NULL;
|
|
struct stream *s = NULL;
|
|
|
|
tui16 bytes_req = 0;
|
|
int bytes_read = 0;
|
|
int cmd;
|
|
int i;
|
|
|
|
if (trans == 0)
|
|
return 0;
|
|
|
|
if (trans != g_audio_c_trans_in)
|
|
return 1;
|
|
|
|
ts = trans_get_in_s(trans);
|
|
if (trans_force_read(trans, 3))
|
|
log_message(LOG_LEVEL_ERROR, "sound.c: error reading from transport");
|
|
|
|
ts->p = ts->data + 8;
|
|
in_uint8(ts, cmd);
|
|
in_uint16_le(ts, bytes_req);
|
|
LOG(10, ("sound_sndsrvr_source_data_in: bytes_req %d", bytes_req));
|
|
|
|
xstream_new(s, bytes_req + 2);
|
|
|
|
if (cmd == PA_CMD_SEND_DATA)
|
|
{
|
|
/* set real len later */
|
|
out_uint16_le(s, 0);
|
|
|
|
while (bytes_read < bytes_req)
|
|
{
|
|
if (g_stream_inp == NULL)
|
|
{
|
|
g_stream_inp = (struct stream *) fifo_remove(&g_in_fifo);
|
|
if (g_stream_inp != NULL)
|
|
{
|
|
g_bytes_in_fifo -= g_stream_inp->size;
|
|
LOG(10, (" g_bytes_in_fifo %d", g_bytes_in_fifo));
|
|
}
|
|
}
|
|
|
|
if (g_stream_inp == NULL)
|
|
{
|
|
/* no more data, send what we have */
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (g_bytes_in_stream == 0)
|
|
g_bytes_in_stream = g_stream_inp->size;
|
|
|
|
i = bytes_req - bytes_read;
|
|
|
|
if (i < g_bytes_in_stream)
|
|
{
|
|
xstream_copyin(s, &g_stream_inp->data[g_stream_inp->size - g_bytes_in_stream], i);
|
|
bytes_read += i;
|
|
g_bytes_in_stream -= i;
|
|
}
|
|
else
|
|
{
|
|
xstream_copyin(s, &g_stream_inp->data[g_stream_inp->size - g_bytes_in_stream], g_bytes_in_stream);
|
|
bytes_read += g_bytes_in_stream;
|
|
g_bytes_in_stream = 0;
|
|
xstream_free(g_stream_inp);
|
|
g_stream_inp = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bytes_read)
|
|
{
|
|
s->data[0] = (char) (bytes_read & 0xff);
|
|
s->data[1] = (char) ((bytes_read >> 8) & 0xff);
|
|
}
|
|
|
|
s_mark_end(s);
|
|
|
|
trans_force_write_s(trans, s);
|
|
}
|
|
else if (cmd == PA_CMD_START_REC)
|
|
{
|
|
sound_input_start_recording();
|
|
}
|
|
else if (cmd == PA_CMD_STOP_REC)
|
|
{
|
|
sound_input_stop_recording();
|
|
}
|
|
|
|
xstream_free(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Start a listener for microphone redirection connections
|
|
*****************************************************************************/
|
|
static int
|
|
sound_start_source_listener(void)
|
|
{
|
|
char port[1024];
|
|
|
|
g_audio_l_trans_in = trans_create(TRANS_MODE_UNIX, 128 * 1024, 8192);
|
|
g_audio_l_trans_in->is_term = g_is_term;
|
|
g_snprintf(port, 255, CHANSRV_PORT_IN_STR, g_display_num);
|
|
g_audio_l_trans_in->trans_conn_in = sound_sndsrvr_source_conn_in;
|
|
if (trans_listen(g_audio_l_trans_in, port) != 0)
|
|
LOG(0, ("trans_listen failed"));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Start a listener for speaker redirection connections
|
|
*****************************************************************************/
|
|
static int
|
|
sound_start_sink_listener(void)
|
|
{
|
|
char port[1024];
|
|
|
|
g_audio_l_trans_out = trans_create(TRANS_MODE_UNIX, 128 * 1024, 8192);
|
|
g_audio_l_trans_out->is_term = g_is_term;
|
|
g_snprintf(port, 255, CHANSRV_PORT_OUT_STR, g_display_num);
|
|
g_audio_l_trans_out->trans_conn_in = sound_sndsrvr_sink_conn_in;
|
|
if (trans_listen(g_audio_l_trans_out, port) != 0)
|
|
LOG(0, ("trans_listen failed"));
|
|
return 0;
|
|
}
|
|
|