FreeRDP
Loading...
Searching...
No Matches
client/rdpsnd_main.c
1
25#include <freerdp/config.h>
26
27#ifndef _WIN32
28#include <sys/time.h>
29#include <signal.h>
30#endif
31
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <errno.h>
36
37#include <winpr/crt.h>
38#include <winpr/assert.h>
39#include <winpr/wlog.h>
40#include <winpr/stream.h>
41#include <winpr/cmdline.h>
42#include <winpr/sysinfo.h>
43#include <winpr/collections.h>
44
45#include <freerdp/types.h>
46#include <freerdp/addin.h>
47#include <freerdp/freerdp.h>
48#include <freerdp/codec/dsp.h>
49#include <freerdp/client/channels.h>
50
51#include "rdpsnd_common.h"
52#include "rdpsnd_main.h"
53
54struct rdpsnd_plugin
55{
56 IWTSPlugin iface;
57 IWTSListener* listener;
58 GENERIC_LISTENER_CALLBACK* listener_callback;
59
60 CHANNEL_DEF channelDef;
61 CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;
62
63 wStreamPool* pool;
64 wStream* data_in;
65
66 void* InitHandle;
67 DWORD OpenHandle;
68
69 wLog* log;
70
71 BYTE cBlockNo;
72 UINT16 wQualityMode;
73 UINT16 wCurrentFormatNo;
74
75 AUDIO_FORMAT* ServerFormats;
76 UINT16 NumberOfServerFormats;
77
78 AUDIO_FORMAT* ClientFormats;
79 UINT16 NumberOfClientFormats;
80
81 BOOL attached;
82 BOOL connected;
83 BOOL dynamic;
84
85 BOOL expectingWave;
86 BYTE waveData[4];
87 UINT16 waveDataSize;
88 UINT16 wTimeStamp;
89 UINT64 wArrivalTime;
90
91 UINT32 latency;
92 BOOL isOpen;
93 AUDIO_FORMAT* fixed_format;
94
95 UINT32 startPlayTime;
96 size_t totalPlaySize;
97
98 char* subsystem;
99 char* device_name;
100
101 /* Device plugin */
102 rdpsndDevicePlugin* device;
103 rdpContext* rdpcontext;
104
105 FREERDP_DSP_CONTEXT* dsp_context;
106
107 HANDLE thread;
108 wMessageQueue* queue;
109 BOOL initialized;
110
111 UINT16 wVersion;
112 UINT32 volume;
113 BOOL applyVolume;
114
115 size_t references;
116 BOOL OnOpenCalled;
117 BOOL async;
118};
119
120static DWORD WINAPI play_thread(LPVOID arg);
121
122static const char* rdpsnd_is_dyn_str(BOOL dynamic)
123{
124 if (dynamic)
125 return "[dynamic]";
126 return "[static]";
127}
128
129static void rdpsnd_virtual_channel_event_terminated(rdpsndPlugin* rdpsnd);
130
136static UINT rdpsnd_virtual_channel_write(rdpsndPlugin* rdpsnd, wStream* s);
137
143static UINT rdpsnd_send_quality_mode_pdu(rdpsndPlugin* rdpsnd)
144{
145 wStream* pdu = NULL;
146 WINPR_ASSERT(rdpsnd);
147 pdu = Stream_New(NULL, 8);
148
149 if (!pdu)
150 {
151 WLog_ERR(TAG, "%s Stream_New failed!", rdpsnd_is_dyn_str(rdpsnd->dynamic));
152 return CHANNEL_RC_NO_MEMORY;
153 }
154
155 Stream_Write_UINT8(pdu, SNDC_QUALITYMODE); /* msgType */
156 Stream_Write_UINT8(pdu, 0); /* bPad */
157 Stream_Write_UINT16(pdu, 4); /* BodySize */
158 Stream_Write_UINT16(pdu, rdpsnd->wQualityMode); /* wQualityMode */
159 Stream_Write_UINT16(pdu, 0); /* Reserved */
160 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s QualityMode: %" PRIu16 "",
161 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->wQualityMode);
162 return rdpsnd_virtual_channel_write(rdpsnd, pdu);
163}
164
165static void rdpsnd_select_supported_audio_formats(rdpsndPlugin* rdpsnd)
166{
167 WINPR_ASSERT(rdpsnd);
168 audio_formats_free(rdpsnd->ClientFormats, rdpsnd->NumberOfClientFormats);
169 rdpsnd->NumberOfClientFormats = 0;
170 rdpsnd->ClientFormats = NULL;
171
172 if (!rdpsnd->NumberOfServerFormats)
173 return;
174
175 rdpsnd->ClientFormats = audio_formats_new(rdpsnd->NumberOfServerFormats);
176
177 if (!rdpsnd->ClientFormats || !rdpsnd->device)
178 return;
179
180 for (UINT16 index = 0; index < rdpsnd->NumberOfServerFormats; index++)
181 {
182 const AUDIO_FORMAT* serverFormat = &rdpsnd->ServerFormats[index];
183
184 if (!audio_format_compatible(rdpsnd->fixed_format, serverFormat))
185 continue;
186
187 WINPR_ASSERT(rdpsnd->device->FormatSupported);
188 if (freerdp_dsp_supports_format(serverFormat, FALSE) ||
189 rdpsnd->device->FormatSupported(rdpsnd->device, serverFormat))
190 {
191 AUDIO_FORMAT* clientFormat = &rdpsnd->ClientFormats[rdpsnd->NumberOfClientFormats++];
192 audio_format_copy(serverFormat, clientFormat);
193 }
194 }
195}
196
202static UINT rdpsnd_send_client_audio_formats(rdpsndPlugin* rdpsnd)
203{
204 wStream* pdu = NULL;
205 UINT16 length = 0;
206 UINT32 dwVolume = 0;
207 UINT16 wNumberOfFormats = 0;
208 WINPR_ASSERT(rdpsnd);
209
210 if (!rdpsnd->device || (!rdpsnd->dynamic && (rdpsnd->OpenHandle == 0)))
211 return CHANNEL_RC_INITIALIZATION_ERROR;
212
213 dwVolume = IFCALLRESULT(0, rdpsnd->device->GetVolume, rdpsnd->device);
214 wNumberOfFormats = rdpsnd->NumberOfClientFormats;
215 length = 4 + 20;
216
217 for (UINT16 index = 0; index < wNumberOfFormats; index++)
218 length += (18 + rdpsnd->ClientFormats[index].cbSize);
219
220 pdu = Stream_New(NULL, length);
221
222 if (!pdu)
223 {
224 WLog_ERR(TAG, "%s Stream_New failed!", rdpsnd_is_dyn_str(rdpsnd->dynamic));
225 return CHANNEL_RC_NO_MEMORY;
226 }
227
228 Stream_Write_UINT8(pdu, SNDC_FORMATS); /* msgType */
229 Stream_Write_UINT8(pdu, 0); /* bPad */
230 Stream_Write_UINT16(pdu, length - 4); /* BodySize */
231 Stream_Write_UINT32(pdu, TSSNDCAPS_ALIVE | TSSNDCAPS_VOLUME); /* dwFlags */
232 Stream_Write_UINT32(pdu, dwVolume); /* dwVolume */
233 Stream_Write_UINT32(pdu, 0); /* dwPitch */
234 Stream_Write_UINT16(pdu, 0); /* wDGramPort */
235 Stream_Write_UINT16(pdu, wNumberOfFormats); /* wNumberOfFormats */
236 Stream_Write_UINT8(pdu, 0); /* cLastBlockConfirmed */
237 Stream_Write_UINT16(pdu, CHANNEL_VERSION_WIN_MAX); /* wVersion */
238 Stream_Write_UINT8(pdu, 0); /* bPad */
239
240 for (UINT16 index = 0; index < wNumberOfFormats; index++)
241 {
242 const AUDIO_FORMAT* clientFormat = &rdpsnd->ClientFormats[index];
243
244 if (!audio_format_write(pdu, clientFormat))
245 {
246 Stream_Free(pdu, TRUE);
247 return ERROR_INTERNAL_ERROR;
248 }
249 }
250
251 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Client Audio Formats",
252 rdpsnd_is_dyn_str(rdpsnd->dynamic));
253 return rdpsnd_virtual_channel_write(rdpsnd, pdu);
254}
255
261static UINT rdpsnd_recv_server_audio_formats_pdu(rdpsndPlugin* rdpsnd, wStream* s)
262{
263 UINT16 wNumberOfFormats = 0;
264 UINT ret = ERROR_BAD_LENGTH;
265
266 WINPR_ASSERT(rdpsnd);
267 audio_formats_free(rdpsnd->ServerFormats, rdpsnd->NumberOfServerFormats);
268 rdpsnd->NumberOfServerFormats = 0;
269 rdpsnd->ServerFormats = NULL;
270
271 if (!Stream_CheckAndLogRequiredLength(TAG, s, 30))
272 return ERROR_BAD_LENGTH;
273
274 /* http://msdn.microsoft.com/en-us/library/cc240956.aspx */
275 Stream_Seek_UINT32(s); /* dwFlags */
276 Stream_Seek_UINT32(s); /* dwVolume */
277 Stream_Seek_UINT32(s); /* dwPitch */
278 Stream_Seek_UINT16(s); /* wDGramPort */
279 Stream_Read_UINT16(s, wNumberOfFormats);
280 Stream_Read_UINT8(s, rdpsnd->cBlockNo); /* cLastBlockConfirmed */
281 Stream_Read_UINT16(s, rdpsnd->wVersion); /* wVersion */
282 Stream_Seek_UINT8(s); /* bPad */
283 rdpsnd->NumberOfServerFormats = wNumberOfFormats;
284
285 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, wNumberOfFormats, 14ull))
286 return ERROR_BAD_LENGTH;
287
288 if (rdpsnd->NumberOfServerFormats > 0)
289 {
290 rdpsnd->ServerFormats = audio_formats_new(wNumberOfFormats);
291
292 if (!rdpsnd->ServerFormats)
293 return CHANNEL_RC_NO_MEMORY;
294
295 for (UINT16 index = 0; index < wNumberOfFormats; index++)
296 {
297 AUDIO_FORMAT* format = &rdpsnd->ServerFormats[index];
298
299 if (!audio_format_read(s, format))
300 goto out_fail;
301 }
302 }
303
304 WINPR_ASSERT(rdpsnd->device);
305 ret = IFCALLRESULT(CHANNEL_RC_OK, rdpsnd->device->ServerFormatAnnounce, rdpsnd->device,
306 rdpsnd->ServerFormats, rdpsnd->NumberOfServerFormats);
307 if (ret != CHANNEL_RC_OK)
308 goto out_fail;
309
310 rdpsnd_select_supported_audio_formats(rdpsnd);
311 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Server Audio Formats",
312 rdpsnd_is_dyn_str(rdpsnd->dynamic));
313 ret = rdpsnd_send_client_audio_formats(rdpsnd);
314
315 if (ret == CHANNEL_RC_OK)
316 {
317 if (rdpsnd->wVersion >= CHANNEL_VERSION_WIN_7)
318 ret = rdpsnd_send_quality_mode_pdu(rdpsnd);
319 }
320
321 return ret;
322out_fail:
323 audio_formats_free(rdpsnd->ServerFormats, rdpsnd->NumberOfServerFormats);
324 rdpsnd->ServerFormats = NULL;
325 rdpsnd->NumberOfServerFormats = 0;
326 return ret;
327}
328
334static UINT rdpsnd_send_training_confirm_pdu(rdpsndPlugin* rdpsnd, UINT16 wTimeStamp,
335 UINT16 wPackSize)
336{
337 wStream* pdu = NULL;
338 WINPR_ASSERT(rdpsnd);
339 pdu = Stream_New(NULL, 8);
340
341 if (!pdu)
342 {
343 WLog_ERR(TAG, "%s Stream_New failed!", rdpsnd_is_dyn_str(rdpsnd->dynamic));
344 return CHANNEL_RC_NO_MEMORY;
345 }
346
347 Stream_Write_UINT8(pdu, SNDC_TRAINING); /* msgType */
348 Stream_Write_UINT8(pdu, 0); /* bPad */
349 Stream_Write_UINT16(pdu, 4); /* BodySize */
350 Stream_Write_UINT16(pdu, wTimeStamp);
351 Stream_Write_UINT16(pdu, wPackSize);
352 WLog_Print(rdpsnd->log, WLOG_DEBUG,
353 "%s Training Response: wTimeStamp: %" PRIu16 " wPackSize: %" PRIu16 "",
354 rdpsnd_is_dyn_str(rdpsnd->dynamic), wTimeStamp, wPackSize);
355 return rdpsnd_virtual_channel_write(rdpsnd, pdu);
356}
357
363static UINT rdpsnd_recv_training_pdu(rdpsndPlugin* rdpsnd, wStream* s)
364{
365 UINT16 wTimeStamp = 0;
366 UINT16 wPackSize = 0;
367 WINPR_ASSERT(rdpsnd);
368 WINPR_ASSERT(s);
369
370 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
371 return ERROR_BAD_LENGTH;
372
373 Stream_Read_UINT16(s, wTimeStamp);
374 Stream_Read_UINT16(s, wPackSize);
375 WLog_Print(rdpsnd->log, WLOG_DEBUG,
376 "%s Training Request: wTimeStamp: %" PRIu16 " wPackSize: %" PRIu16 "",
377 rdpsnd_is_dyn_str(rdpsnd->dynamic), wTimeStamp, wPackSize);
378 return rdpsnd_send_training_confirm_pdu(rdpsnd, wTimeStamp, wPackSize);
379}
380
381static BOOL rdpsnd_apply_volume(rdpsndPlugin* rdpsnd)
382{
383 WINPR_ASSERT(rdpsnd);
384
385 if (rdpsnd->isOpen && rdpsnd->applyVolume && rdpsnd->device)
386 {
387 BOOL rc = IFCALLRESULT(TRUE, rdpsnd->device->SetVolume, rdpsnd->device, rdpsnd->volume);
388 if (!rc)
389 return FALSE;
390 rdpsnd->applyVolume = FALSE;
391 }
392 return TRUE;
393}
394
395static BOOL rdpsnd_ensure_device_is_open(rdpsndPlugin* rdpsnd, UINT16 wFormatNo,
396 const AUDIO_FORMAT* format)
397{
398 if (!rdpsnd)
399 return FALSE;
400 WINPR_ASSERT(format);
401
402 if (!rdpsnd->isOpen || (wFormatNo != rdpsnd->wCurrentFormatNo))
403 {
404 BOOL rc = 0;
405 BOOL supported = 0;
406 AUDIO_FORMAT deviceFormat = *format;
407
408 IFCALL(rdpsnd->device->Close, rdpsnd->device);
409 supported = IFCALLRESULT(FALSE, rdpsnd->device->FormatSupported, rdpsnd->device, format);
410
411 if (!supported)
412 {
413 if (!IFCALLRESULT(FALSE, rdpsnd->device->DefaultFormat, rdpsnd->device, format,
414 &deviceFormat))
415 {
416 deviceFormat.wFormatTag = WAVE_FORMAT_PCM;
417 deviceFormat.wBitsPerSample = 16;
418 deviceFormat.cbSize = 0;
419 }
420 }
421
422 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Opening device with format %s [backend %s]",
423 rdpsnd_is_dyn_str(rdpsnd->dynamic),
424 audio_format_get_tag_string(format->wFormatTag),
425 audio_format_get_tag_string(deviceFormat.wFormatTag));
426 rc = IFCALLRESULT(FALSE, rdpsnd->device->Open, rdpsnd->device, &deviceFormat,
427 rdpsnd->latency);
428
429 if (!rc)
430 return FALSE;
431
432 if (!supported)
433 {
434 if (!freerdp_dsp_context_reset(rdpsnd->dsp_context, format, 0u))
435 return FALSE;
436 }
437
438 rdpsnd->isOpen = TRUE;
439 rdpsnd->wCurrentFormatNo = wFormatNo;
440 rdpsnd->startPlayTime = 0;
441 rdpsnd->totalPlaySize = 0;
442 }
443
444 return rdpsnd_apply_volume(rdpsnd);
445}
446
452static UINT rdpsnd_recv_wave_info_pdu(rdpsndPlugin* rdpsnd, wStream* s, UINT16 BodySize)
453{
454 UINT16 wFormatNo = 0;
455 const AUDIO_FORMAT* format = NULL;
456 WINPR_ASSERT(rdpsnd);
457 WINPR_ASSERT(s);
458
459 if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
460 return ERROR_BAD_LENGTH;
461
462 rdpsnd->wArrivalTime = GetTickCount64();
463 Stream_Read_UINT16(s, rdpsnd->wTimeStamp);
464 Stream_Read_UINT16(s, wFormatNo);
465
466 if (wFormatNo >= rdpsnd->NumberOfClientFormats)
467 return ERROR_INVALID_DATA;
468
469 Stream_Read_UINT8(s, rdpsnd->cBlockNo);
470 Stream_Seek(s, 3); /* bPad */
471 Stream_Read(s, rdpsnd->waveData, 4);
472 rdpsnd->waveDataSize = BodySize - 8;
473 format = &rdpsnd->ClientFormats[wFormatNo];
474 WLog_Print(rdpsnd->log, WLOG_DEBUG,
475 "%s WaveInfo: cBlockNo: %" PRIu8 " wFormatNo: %" PRIu16 " [%s]",
476 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->cBlockNo, wFormatNo,
477 audio_format_get_tag_string(format->wFormatTag));
478
479 if (!rdpsnd_ensure_device_is_open(rdpsnd, wFormatNo, format))
480 return ERROR_INTERNAL_ERROR;
481
482 rdpsnd->expectingWave = TRUE;
483 return CHANNEL_RC_OK;
484}
485
491static UINT rdpsnd_send_wave_confirm_pdu(rdpsndPlugin* rdpsnd, UINT16 wTimeStamp,
492 BYTE cConfirmedBlockNo)
493{
494 wStream* pdu = NULL;
495 WINPR_ASSERT(rdpsnd);
496 pdu = Stream_New(NULL, 8);
497
498 if (!pdu)
499 {
500 WLog_ERR(TAG, "%s Stream_New failed!", rdpsnd_is_dyn_str(rdpsnd->dynamic));
501 return CHANNEL_RC_NO_MEMORY;
502 }
503
504 Stream_Write_UINT8(pdu, SNDC_WAVECONFIRM);
505 Stream_Write_UINT8(pdu, 0);
506 Stream_Write_UINT16(pdu, 4);
507 Stream_Write_UINT16(pdu, wTimeStamp);
508 Stream_Write_UINT8(pdu, cConfirmedBlockNo); /* cConfirmedBlockNo */
509 Stream_Write_UINT8(pdu, 0); /* bPad */
510 return rdpsnd_virtual_channel_write(rdpsnd, pdu);
511}
512
513static BOOL rdpsnd_detect_overrun(rdpsndPlugin* rdpsnd, const AUDIO_FORMAT* format, size_t size)
514{
515 UINT32 bpf = 0;
516 UINT32 now = 0;
517 UINT32 duration = 0;
518 UINT32 totalDuration = 0;
519 UINT32 remainingDuration = 0;
520 UINT32 maxDuration = 0;
521
522 if (!rdpsnd || !format)
523 return FALSE;
524
525 /* Older windows RDP servers do not limit the send buffer, which can
526 * cause quite a large amount of sound data buffered client side.
527 * If e.g. sound is paused server side the client will keep playing
528 * for a long time instead of pausing playback.
529 *
530 * To avoid this we check:
531 *
532 * 1. Is the sound sample received from a known format these servers
533 * support
534 * 2. If it is calculate the size of the client side sound buffer
535 * 3. If the buffer is too large silently drop the sample which will
536 * trigger a retransmit later on.
537 *
538 * This check must only be applied to these known formats, because
539 * with newer and other formats the sample size can not be calculated
540 * without decompressing the sample first.
541 */
542 switch (format->wFormatTag)
543 {
544 case WAVE_FORMAT_PCM:
545 case WAVE_FORMAT_DVI_ADPCM:
546 case WAVE_FORMAT_ADPCM:
547 case WAVE_FORMAT_ALAW:
548 case WAVE_FORMAT_MULAW:
549 break;
550 case WAVE_FORMAT_MSG723:
551 case WAVE_FORMAT_GSM610:
552 case WAVE_FORMAT_AAC_MS:
553 default:
554 return FALSE;
555 }
556
557 audio_format_print(WLog_Get(TAG), WLOG_DEBUG, format);
558 bpf = format->nChannels * format->wBitsPerSample * format->nSamplesPerSec / 8;
559 if (bpf == 0)
560 return FALSE;
561
562 duration = (UINT32)(1000 * size / bpf);
563 totalDuration = (UINT32)(1000 * rdpsnd->totalPlaySize / bpf);
564 now = GetTickCountPrecise();
565 if (rdpsnd->startPlayTime == 0)
566 {
567 rdpsnd->startPlayTime = now;
568 rdpsnd->totalPlaySize = size;
569 return FALSE;
570 }
571 else if (now - rdpsnd->startPlayTime > totalDuration + 10)
572 {
573 /* Buffer underrun */
574 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Buffer underrun by %u ms",
575 rdpsnd_is_dyn_str(rdpsnd->dynamic),
576 (UINT)(now - rdpsnd->startPlayTime - totalDuration));
577 rdpsnd->startPlayTime = now;
578 rdpsnd->totalPlaySize = size;
579 return FALSE;
580 }
581 else
582 {
583 /* Calculate remaining duration to be played */
584 remainingDuration = totalDuration - (now - rdpsnd->startPlayTime);
585
586 /* Maximum allow duration calculation */
587 maxDuration = duration * 2 + rdpsnd->latency;
588
589 if (remainingDuration + duration > maxDuration)
590 {
591 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Buffer overrun pending %u ms dropping %u ms",
592 rdpsnd_is_dyn_str(rdpsnd->dynamic), remainingDuration, duration);
593 return TRUE;
594 }
595
596 rdpsnd->totalPlaySize += size;
597 return FALSE;
598 }
599}
600
601static UINT rdpsnd_treat_wave(rdpsndPlugin* rdpsnd, wStream* s, size_t size)
602{
603 AUDIO_FORMAT* format = NULL;
604 UINT64 end = 0;
605 UINT64 diffMS = 0;
606 UINT64 ts = 0;
607 UINT latency = 0;
608 UINT error = 0;
609
610 if (!Stream_CheckAndLogRequiredLength(TAG, s, size))
611 return ERROR_BAD_LENGTH;
612
613 if (rdpsnd->wCurrentFormatNo >= rdpsnd->NumberOfClientFormats)
614 return ERROR_INTERNAL_ERROR;
615
616 /*
617 * Send the first WaveConfirm PDU. The server side uses this to determine the
618 * network latency.
619 * See also [MS-RDPEA] 2.2.3.8 Wave Confirm PDU
620 */
621 error = rdpsnd_send_wave_confirm_pdu(rdpsnd, rdpsnd->wTimeStamp, rdpsnd->cBlockNo);
622 if (error)
623 return error;
624
625 const BYTE* data = Stream_ConstPointer(s);
626 format = &rdpsnd->ClientFormats[rdpsnd->wCurrentFormatNo];
627 WLog_Print(rdpsnd->log, WLOG_DEBUG,
628 "%s Wave: cBlockNo: %" PRIu8 " wTimeStamp: %" PRIu16 ", size: %" PRIuz,
629 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->cBlockNo, rdpsnd->wTimeStamp, size);
630
631 if (rdpsnd->device && rdpsnd->attached && !rdpsnd_detect_overrun(rdpsnd, format, size))
632 {
633 UINT status = CHANNEL_RC_OK;
634 wStream* pcmData = StreamPool_Take(rdpsnd->pool, 4096);
635
636 if (rdpsnd->device->FormatSupported(rdpsnd->device, format))
637 {
638 if (rdpsnd->device->PlayEx)
639 latency = rdpsnd->device->PlayEx(rdpsnd->device, format, data, size);
640 else
641 latency = IFCALLRESULT(0, rdpsnd->device->Play, rdpsnd->device, data, size);
642 }
643 else if (freerdp_dsp_decode(rdpsnd->dsp_context, format, data, size, pcmData))
644 {
645 Stream_SealLength(pcmData);
646
647 if (rdpsnd->device->PlayEx)
648 latency = rdpsnd->device->PlayEx(rdpsnd->device, format, Stream_Buffer(pcmData),
649 Stream_Length(pcmData));
650 else
651 latency = IFCALLRESULT(0, rdpsnd->device->Play, rdpsnd->device,
652 Stream_Buffer(pcmData), Stream_Length(pcmData));
653 }
654 else
655 status = ERROR_INTERNAL_ERROR;
656
657 Stream_Release(pcmData);
658
659 if (status != CHANNEL_RC_OK)
660 return status;
661 }
662
663 end = GetTickCount64();
664 diffMS = end - rdpsnd->wArrivalTime + latency;
665 ts = (rdpsnd->wTimeStamp + diffMS) % UINT16_MAX;
666
667 /*
668 * Send the second WaveConfirm PDU. With the first WaveConfirm PDU,
669 * the server side uses this second WaveConfirm PDU to determine the actual
670 * render latency.
671 */
672 return rdpsnd_send_wave_confirm_pdu(rdpsnd, (UINT16)ts, rdpsnd->cBlockNo);
673}
674
680static UINT rdpsnd_recv_wave_pdu(rdpsndPlugin* rdpsnd, wStream* s)
681{
682 rdpsnd->expectingWave = FALSE;
683
690 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
691 return ERROR_INVALID_DATA;
692
693 CopyMemory(Stream_Buffer(s), rdpsnd->waveData, 4);
694 return rdpsnd_treat_wave(rdpsnd, s, rdpsnd->waveDataSize);
695}
696
697static UINT rdpsnd_recv_wave2_pdu(rdpsndPlugin* rdpsnd, wStream* s, UINT16 BodySize)
698{
699 UINT16 wFormatNo = 0;
700 AUDIO_FORMAT* format = NULL;
701 UINT32 dwAudioTimeStamp = 0;
702
703 if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
704 return ERROR_BAD_LENGTH;
705
706 Stream_Read_UINT16(s, rdpsnd->wTimeStamp);
707 Stream_Read_UINT16(s, wFormatNo);
708 Stream_Read_UINT8(s, rdpsnd->cBlockNo);
709 Stream_Seek(s, 3); /* bPad */
710 Stream_Read_UINT32(s, dwAudioTimeStamp);
711 if (wFormatNo >= rdpsnd->NumberOfClientFormats)
712 return ERROR_INVALID_DATA;
713 format = &rdpsnd->ClientFormats[wFormatNo];
714 rdpsnd->waveDataSize = BodySize - 12;
715 rdpsnd->wArrivalTime = GetTickCount64();
716 WLog_Print(rdpsnd->log, WLOG_DEBUG,
717 "%s Wave2PDU: cBlockNo: %" PRIu8 " wFormatNo: %" PRIu16
718 " [%s] , align=%hu wTimeStamp=0x%04" PRIx16 ", dwAudioTimeStamp=0x%08" PRIx32,
719 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->cBlockNo, wFormatNo,
720 audio_format_get_tag_string(format->wFormatTag), format->nBlockAlign,
721 rdpsnd->wTimeStamp, dwAudioTimeStamp);
722
723 if (!rdpsnd_ensure_device_is_open(rdpsnd, wFormatNo, format))
724 return ERROR_INTERNAL_ERROR;
725
726 return rdpsnd_treat_wave(rdpsnd, s, rdpsnd->waveDataSize);
727}
728
729static void rdpsnd_recv_close_pdu(rdpsndPlugin* rdpsnd)
730{
731 if (rdpsnd->isOpen)
732 {
733 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Closing device",
734 rdpsnd_is_dyn_str(rdpsnd->dynamic));
735 }
736 else
737 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Device already closed",
738 rdpsnd_is_dyn_str(rdpsnd->dynamic));
739}
740
746static UINT rdpsnd_recv_volume_pdu(rdpsndPlugin* rdpsnd, wStream* s)
747{
748 BOOL rc = TRUE;
749 UINT32 dwVolume = 0;
750
751 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
752 return ERROR_BAD_LENGTH;
753
754 Stream_Read_UINT32(s, dwVolume);
755 WLog_Print(rdpsnd->log, WLOG_DEBUG, "%s Volume: 0x%08" PRIX32 "",
756 rdpsnd_is_dyn_str(rdpsnd->dynamic), dwVolume);
757
758 rdpsnd->volume = dwVolume;
759 rdpsnd->applyVolume = TRUE;
760 rc = rdpsnd_apply_volume(rdpsnd);
761
762 if (!rc)
763 {
764 WLog_ERR(TAG, "%s error setting volume", rdpsnd_is_dyn_str(rdpsnd->dynamic));
765 return CHANNEL_RC_INITIALIZATION_ERROR;
766 }
767
768 return CHANNEL_RC_OK;
769}
770
776static UINT rdpsnd_recv_pdu(rdpsndPlugin* rdpsnd, wStream* s)
777{
778 BYTE msgType = 0;
779 UINT16 BodySize = 0;
780 UINT status = CHANNEL_RC_OK;
781
782 if (rdpsnd->expectingWave)
783 {
784 status = rdpsnd_recv_wave_pdu(rdpsnd, s);
785 goto out;
786 }
787
788 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
789 {
790 status = ERROR_BAD_LENGTH;
791 goto out;
792 }
793
794 Stream_Read_UINT8(s, msgType); /* msgType */
795 Stream_Seek_UINT8(s); /* bPad */
796 Stream_Read_UINT16(s, BodySize);
797
798 switch (msgType)
799 {
800 case SNDC_FORMATS:
801 status = rdpsnd_recv_server_audio_formats_pdu(rdpsnd, s);
802 break;
803
804 case SNDC_TRAINING:
805 status = rdpsnd_recv_training_pdu(rdpsnd, s);
806 break;
807
808 case SNDC_WAVE:
809 status = rdpsnd_recv_wave_info_pdu(rdpsnd, s, BodySize);
810 break;
811
812 case SNDC_CLOSE:
813 rdpsnd_recv_close_pdu(rdpsnd);
814 break;
815
816 case SNDC_SETVOLUME:
817 status = rdpsnd_recv_volume_pdu(rdpsnd, s);
818 break;
819
820 case SNDC_WAVE2:
821 status = rdpsnd_recv_wave2_pdu(rdpsnd, s, BodySize);
822 break;
823
824 default:
825 WLog_ERR(TAG, "%s unknown msgType %" PRIu8 "", rdpsnd_is_dyn_str(rdpsnd->dynamic),
826 msgType);
827 break;
828 }
829
830out:
831 Stream_Release(s);
832 return status;
833}
834
835static void rdpsnd_register_device_plugin(rdpsndPlugin* rdpsnd, rdpsndDevicePlugin* device)
836{
837 if (rdpsnd->device)
838 {
839 WLog_ERR(TAG, "%s existing device, abort.", rdpsnd_is_dyn_str(FALSE));
840 return;
841 }
842
843 rdpsnd->device = device;
844 device->rdpsnd = rdpsnd;
845}
846
852static UINT rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name,
853 const ADDIN_ARGV* args)
854{
855 FREERDP_RDPSND_DEVICE_ENTRY_POINTS entryPoints = { 0 };
856 UINT error = 0;
857 DWORD flags = FREERDP_ADDIN_CHANNEL_STATIC | FREERDP_ADDIN_CHANNEL_ENTRYEX;
858 if (rdpsnd->dynamic)
859 flags = FREERDP_ADDIN_CHANNEL_DYNAMIC;
860 PVIRTUALCHANNELENTRY pvce =
861 freerdp_load_channel_addin_entry(RDPSND_CHANNEL_NAME, name, NULL, flags);
862 PFREERDP_RDPSND_DEVICE_ENTRY entry = WINPR_FUNC_PTR_CAST(pvce, PFREERDP_RDPSND_DEVICE_ENTRY);
863
864 if (!entry)
865 return ERROR_INTERNAL_ERROR;
866
867 entryPoints.rdpsnd = rdpsnd;
868 entryPoints.pRegisterRdpsndDevice = rdpsnd_register_device_plugin;
869 entryPoints.args = args;
870
871 error = entry(&entryPoints);
872 if (error)
873 WLog_ERR(TAG, "%s %s entry returns error %" PRIu32 "", rdpsnd_is_dyn_str(rdpsnd->dynamic),
874 name, error);
875
876 WLog_INFO(TAG, "%s Loaded %s backend for rdpsnd", rdpsnd_is_dyn_str(rdpsnd->dynamic), name);
877 return error;
878}
879
880static BOOL rdpsnd_set_subsystem(rdpsndPlugin* rdpsnd, const char* subsystem)
881{
882 free(rdpsnd->subsystem);
883 rdpsnd->subsystem = _strdup(subsystem);
884 return (rdpsnd->subsystem != NULL);
885}
886
887static BOOL rdpsnd_set_device_name(rdpsndPlugin* rdpsnd, const char* device_name)
888{
889 free(rdpsnd->device_name);
890 rdpsnd->device_name = _strdup(device_name);
891 return (rdpsnd->device_name != NULL);
892}
893
899static UINT rdpsnd_process_addin_args(rdpsndPlugin* rdpsnd, const ADDIN_ARGV* args)
900{
901 int status = 0;
902 DWORD flags = 0;
903 const COMMAND_LINE_ARGUMENT_A* arg = NULL;
904 COMMAND_LINE_ARGUMENT_A rdpsnd_args[] = {
905 { "sys", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", NULL, NULL, -1, NULL, "subsystem" },
906 { "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL, NULL, -1, NULL, "device" },
907 { "format", COMMAND_LINE_VALUE_REQUIRED, "<format>", NULL, NULL, -1, NULL, "format" },
908 { "rate", COMMAND_LINE_VALUE_REQUIRED, "<rate>", NULL, NULL, -1, NULL, "rate" },
909 { "channel", COMMAND_LINE_VALUE_REQUIRED, "<channel>", NULL, NULL, -1, NULL, "channel" },
910 { "latency", COMMAND_LINE_VALUE_REQUIRED, "<latency>", NULL, NULL, -1, NULL, "latency" },
911 { "quality", COMMAND_LINE_VALUE_REQUIRED, "<quality mode>", NULL, NULL, -1, NULL,
912 "quality mode" },
913 { NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
914 };
915 rdpsnd->wQualityMode = HIGH_QUALITY; /* default quality mode */
916
917 if (args->argc > 1)
918 {
919 flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON;
920 status = CommandLineParseArgumentsA(args->argc, args->argv, rdpsnd_args, flags, rdpsnd,
921 NULL, NULL);
922
923 if (status < 0)
924 return CHANNEL_RC_INITIALIZATION_ERROR;
925
926 arg = rdpsnd_args;
927 errno = 0;
928
929 do
930 {
931 if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
932 continue;
933
934 CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "sys")
935 {
936 if (!rdpsnd_set_subsystem(rdpsnd, arg->Value))
937 return CHANNEL_RC_NO_MEMORY;
938 }
939 CommandLineSwitchCase(arg, "dev")
940 {
941 if (!rdpsnd_set_device_name(rdpsnd, arg->Value))
942 return CHANNEL_RC_NO_MEMORY;
943 }
944 CommandLineSwitchCase(arg, "format")
945 {
946 unsigned long val = strtoul(arg->Value, NULL, 0);
947
948 if ((errno != 0) || (val > UINT16_MAX))
949 return CHANNEL_RC_INITIALIZATION_ERROR;
950
951 rdpsnd->fixed_format->wFormatTag = (UINT16)val;
952 }
953 CommandLineSwitchCase(arg, "rate")
954 {
955 unsigned long val = strtoul(arg->Value, NULL, 0);
956
957 if ((errno != 0) || (val > UINT32_MAX))
958 return CHANNEL_RC_INITIALIZATION_ERROR;
959
960 rdpsnd->fixed_format->nSamplesPerSec = (UINT32)val;
961 }
962 CommandLineSwitchCase(arg, "channel")
963 {
964 unsigned long val = strtoul(arg->Value, NULL, 0);
965
966 if ((errno != 0) || (val > UINT16_MAX))
967 return CHANNEL_RC_INITIALIZATION_ERROR;
968
969 rdpsnd->fixed_format->nChannels = (UINT16)val;
970 }
971 CommandLineSwitchCase(arg, "latency")
972 {
973 unsigned long val = strtoul(arg->Value, NULL, 0);
974
975 if ((errno != 0) || (val > UINT32_MAX))
976 return CHANNEL_RC_INITIALIZATION_ERROR;
977
978 rdpsnd->latency = (UINT32)val;
979 }
980 CommandLineSwitchCase(arg, "quality")
981 {
982 long wQualityMode = DYNAMIC_QUALITY;
983
984 if (_stricmp(arg->Value, "dynamic") == 0)
985 wQualityMode = DYNAMIC_QUALITY;
986 else if (_stricmp(arg->Value, "medium") == 0)
987 wQualityMode = MEDIUM_QUALITY;
988 else if (_stricmp(arg->Value, "high") == 0)
989 wQualityMode = HIGH_QUALITY;
990 else
991 {
992 wQualityMode = strtol(arg->Value, NULL, 0);
993
994 if (errno != 0)
995 return CHANNEL_RC_INITIALIZATION_ERROR;
996 }
997
998 if ((wQualityMode < 0) || (wQualityMode > 2))
999 wQualityMode = DYNAMIC_QUALITY;
1000
1001 rdpsnd->wQualityMode = (UINT16)wQualityMode;
1002 }
1003 CommandLineSwitchDefault(arg)
1004 {
1005 }
1006 CommandLineSwitchEnd(arg)
1007 } while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
1008 }
1009
1010 return CHANNEL_RC_OK;
1011}
1012
1018static UINT rdpsnd_process_connect(rdpsndPlugin* rdpsnd)
1019{
1020 const struct
1021 {
1022 const char* subsystem;
1023 const char* device;
1024 } backends[] = {
1025#if defined(WITH_IOSAUDIO)
1026 { "ios", "" },
1027#endif
1028#if defined(WITH_OPENSLES)
1029 { "opensles", "" },
1030#endif
1031#if defined(WITH_PULSE)
1032 { "pulse", "" },
1033#endif
1034#if defined(WITH_ALSA)
1035 { "alsa", "default" },
1036#endif
1037#if defined(WITH_OSS)
1038 { "oss", "" },
1039#endif
1040#if defined(WITH_MACAUDIO)
1041 { "mac", "default" },
1042#endif
1043#if defined(WITH_WINMM)
1044 { "winmm", "" },
1045#endif
1046#if defined(WITH_SNDIO)
1047 { "sndio", "" },
1048#endif
1049 { "fake", "" }
1050 };
1051 const ADDIN_ARGV* args = NULL;
1052 UINT status = ERROR_INTERNAL_ERROR;
1053 WINPR_ASSERT(rdpsnd);
1054 rdpsnd->latency = 0;
1055 args = (const ADDIN_ARGV*)rdpsnd->channelEntryPoints.pExtendedData;
1056
1057 if (args)
1058 {
1059 status = rdpsnd_process_addin_args(rdpsnd, args);
1060
1061 if (status != CHANNEL_RC_OK)
1062 return status;
1063 }
1064
1065 if (rdpsnd->subsystem)
1066 {
1067 if ((status = rdpsnd_load_device_plugin(rdpsnd, rdpsnd->subsystem, args)))
1068 {
1069 WLog_ERR(TAG,
1070 "%s Unable to load sound playback subsystem %s because of error %" PRIu32 "",
1071 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->subsystem, status);
1072 return status;
1073 }
1074 }
1075 else
1076 {
1077 for (size_t x = 0; x < ARRAYSIZE(backends); x++)
1078 {
1079 const char* subsystem_name = backends[x].subsystem;
1080 const char* device_name = backends[x].device;
1081
1082 if ((status = rdpsnd_load_device_plugin(rdpsnd, subsystem_name, args)))
1083 WLog_ERR(TAG,
1084 "%s Unable to load sound playback subsystem %s because of error %" PRIu32
1085 "",
1086 rdpsnd_is_dyn_str(rdpsnd->dynamic), subsystem_name, status);
1087
1088 if (!rdpsnd->device)
1089 continue;
1090
1091 if (!rdpsnd_set_subsystem(rdpsnd, subsystem_name) ||
1092 !rdpsnd_set_device_name(rdpsnd, device_name))
1093 return CHANNEL_RC_NO_MEMORY;
1094
1095 break;
1096 }
1097
1098 if (!rdpsnd->device || status)
1099 return CHANNEL_RC_INITIALIZATION_ERROR;
1100 }
1101
1102 return CHANNEL_RC_OK;
1103}
1104
1110UINT rdpsnd_virtual_channel_write(rdpsndPlugin* rdpsnd, wStream* s)
1111{
1112 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
1113
1114 if (rdpsnd)
1115 {
1116 if (rdpsnd->dynamic)
1117 {
1118 IWTSVirtualChannel* channel = NULL;
1119 if (rdpsnd->listener_callback)
1120 {
1121 channel = rdpsnd->listener_callback->channel_callback->channel;
1122 status = channel->Write(channel, (UINT32)Stream_Length(s), Stream_Buffer(s), NULL);
1123 }
1124 Stream_Free(s, TRUE);
1125 }
1126 else
1127 {
1128 status = rdpsnd->channelEntryPoints.pVirtualChannelWriteEx(
1129 rdpsnd->InitHandle, rdpsnd->OpenHandle, Stream_Buffer(s),
1130 (UINT32)Stream_GetPosition(s), s);
1131
1132 if (status != CHANNEL_RC_OK)
1133 {
1134 Stream_Free(s, TRUE);
1135 WLog_ERR(TAG, "%s pVirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1136 rdpsnd_is_dyn_str(FALSE), WTSErrorToString(status), status);
1137 }
1138 }
1139 }
1140
1141 return status;
1142}
1143
1149static UINT rdpsnd_virtual_channel_event_data_received(rdpsndPlugin* plugin, void* pData,
1150 UINT32 dataLength, UINT32 totalLength,
1151 UINT32 dataFlags)
1152{
1153 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1154 return CHANNEL_RC_OK;
1155
1156 if (dataFlags & CHANNEL_FLAG_FIRST)
1157 {
1158 if (!plugin->data_in)
1159 plugin->data_in = StreamPool_Take(plugin->pool, totalLength);
1160
1161 Stream_SetPosition(plugin->data_in, 0);
1162 }
1163
1164 if (!Stream_EnsureRemainingCapacity(plugin->data_in, dataLength))
1165 return CHANNEL_RC_NO_MEMORY;
1166
1167 Stream_Write(plugin->data_in, pData, dataLength);
1168
1169 if (dataFlags & CHANNEL_FLAG_LAST)
1170 {
1171 Stream_SealLength(plugin->data_in);
1172 Stream_SetPosition(plugin->data_in, 0);
1173
1174 if (plugin->async)
1175 {
1176 if (!MessageQueue_Post(plugin->queue, NULL, 0, plugin->data_in, NULL))
1177 return ERROR_INTERNAL_ERROR;
1178 plugin->data_in = NULL;
1179 }
1180 else
1181 {
1182 UINT error = rdpsnd_recv_pdu(plugin, plugin->data_in);
1183 plugin->data_in = NULL;
1184 if (error)
1185 return error;
1186 }
1187 }
1188
1189 return CHANNEL_RC_OK;
1190}
1191
1192static VOID VCAPITYPE rdpsnd_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1193 UINT event, LPVOID pData,
1194 UINT32 dataLength, UINT32 totalLength,
1195 UINT32 dataFlags)
1196{
1197 UINT error = CHANNEL_RC_OK;
1198 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)lpUserParam;
1199 WINPR_ASSERT(rdpsnd);
1200 WINPR_ASSERT(!rdpsnd->dynamic);
1201
1202 switch (event)
1203 {
1204 case CHANNEL_EVENT_DATA_RECEIVED:
1205 if (!rdpsnd)
1206 return;
1207
1208 if (rdpsnd->OpenHandle != openHandle)
1209 {
1210 WLog_ERR(TAG, "%s error no match", rdpsnd_is_dyn_str(rdpsnd->dynamic));
1211 return;
1212 }
1213 if ((error = rdpsnd_virtual_channel_event_data_received(rdpsnd, pData, dataLength,
1214 totalLength, dataFlags)))
1215 WLog_ERR(TAG,
1216 "%s rdpsnd_virtual_channel_event_data_received failed with error %" PRIu32
1217 "",
1218 rdpsnd_is_dyn_str(rdpsnd->dynamic), error);
1219
1220 break;
1221
1222 case CHANNEL_EVENT_WRITE_CANCELLED:
1223 case CHANNEL_EVENT_WRITE_COMPLETE:
1224 {
1225 wStream* s = (wStream*)pData;
1226 Stream_Free(s, TRUE);
1227 }
1228 break;
1229
1230 case CHANNEL_EVENT_USER:
1231 break;
1232 default:
1233 break;
1234 }
1235
1236 if (error && rdpsnd && rdpsnd->rdpcontext)
1237 {
1238 char buffer[8192];
1239 (void)_snprintf(buffer, sizeof(buffer),
1240 "%s rdpsnd_virtual_channel_open_event_ex reported an error",
1241 rdpsnd_is_dyn_str(rdpsnd->dynamic));
1242 setChannelError(rdpsnd->rdpcontext, error, buffer);
1243 }
1244}
1245
1251static UINT rdpsnd_virtual_channel_event_connected(rdpsndPlugin* rdpsnd, LPVOID pData,
1252 UINT32 dataLength)
1253{
1254 UINT32 status = 0;
1255 DWORD opened = 0;
1256 WINPR_UNUSED(pData);
1257 WINPR_UNUSED(dataLength);
1258
1259 WINPR_ASSERT(rdpsnd);
1260 WINPR_ASSERT(!rdpsnd->dynamic);
1261
1262 status = rdpsnd->channelEntryPoints.pVirtualChannelOpenEx(
1263 rdpsnd->InitHandle, &opened, rdpsnd->channelDef.name, rdpsnd_virtual_channel_open_event_ex);
1264
1265 if (status != CHANNEL_RC_OK)
1266 {
1267 WLog_ERR(TAG, "%s pVirtualChannelOpenEx failed with %s [%08" PRIX32 "]",
1268 rdpsnd_is_dyn_str(rdpsnd->dynamic), WTSErrorToString(status), status);
1269 goto fail;
1270 }
1271
1272 if (rdpsnd_process_connect(rdpsnd) != CHANNEL_RC_OK)
1273 goto fail;
1274
1275 rdpsnd->OpenHandle = opened;
1276 return CHANNEL_RC_OK;
1277fail:
1278 if (opened != 0)
1279 rdpsnd->channelEntryPoints.pVirtualChannelCloseEx(rdpsnd->InitHandle, opened);
1280 return CHANNEL_RC_NO_MEMORY;
1281}
1282
1283static void rdpsnd_terminate_thread(rdpsndPlugin* rdpsnd)
1284{
1285 WINPR_ASSERT(rdpsnd);
1286 if (rdpsnd->queue)
1287 MessageQueue_PostQuit(rdpsnd->queue, 0);
1288
1289 if (rdpsnd->thread)
1290 {
1291 (void)WaitForSingleObject(rdpsnd->thread, INFINITE);
1292 (void)CloseHandle(rdpsnd->thread);
1293 }
1294
1295 MessageQueue_Free(rdpsnd->queue);
1296 rdpsnd->thread = NULL;
1297 rdpsnd->queue = NULL;
1298}
1299
1300static void cleanup_internals(rdpsndPlugin* rdpsnd)
1301{
1302 if (!rdpsnd)
1303 return;
1304
1305 if (rdpsnd->pool)
1306 StreamPool_Return(rdpsnd->pool, rdpsnd->data_in);
1307
1308 audio_formats_free(rdpsnd->ClientFormats, rdpsnd->NumberOfClientFormats);
1309 audio_formats_free(rdpsnd->ServerFormats, rdpsnd->NumberOfServerFormats);
1310
1311 rdpsnd->NumberOfClientFormats = 0;
1312 rdpsnd->ClientFormats = NULL;
1313 rdpsnd->NumberOfServerFormats = 0;
1314 rdpsnd->ServerFormats = NULL;
1315
1316 rdpsnd->data_in = NULL;
1317}
1318
1324static UINT rdpsnd_virtual_channel_event_disconnected(rdpsndPlugin* rdpsnd)
1325{
1326 UINT error = 0;
1327
1328 WINPR_ASSERT(rdpsnd);
1329 WINPR_ASSERT(!rdpsnd->dynamic);
1330 if (rdpsnd->OpenHandle != 0)
1331 {
1332 DWORD opened = rdpsnd->OpenHandle;
1333 rdpsnd->OpenHandle = 0;
1334 if (rdpsnd->device)
1335 IFCALL(rdpsnd->device->Close, rdpsnd->device);
1336
1337 error = rdpsnd->channelEntryPoints.pVirtualChannelCloseEx(rdpsnd->InitHandle, opened);
1338
1339 if (CHANNEL_RC_OK != error)
1340 {
1341 WLog_ERR(TAG, "%s pVirtualChannelCloseEx failed with %s [%08" PRIX32 "]",
1342 rdpsnd_is_dyn_str(rdpsnd->dynamic), WTSErrorToString(error), error);
1343 return error;
1344 }
1345 }
1346
1347 cleanup_internals(rdpsnd);
1348
1349 if (rdpsnd->device)
1350 {
1351 IFCALL(rdpsnd->device->Free, rdpsnd->device);
1352 rdpsnd->device = NULL;
1353 }
1354
1355 return CHANNEL_RC_OK;
1356}
1357
1358static void queue_free(void* obj)
1359{
1360 wMessage* msg = obj;
1361 if (!msg)
1362 return;
1363 if (msg->id != 0)
1364 return;
1365 wStream* s = msg->wParam;
1366 Stream_Release(s);
1367}
1368
1369static void free_internals(rdpsndPlugin* rdpsnd)
1370{
1371 if (!rdpsnd)
1372 return;
1373
1374 if (rdpsnd->references > 0)
1375 rdpsnd->references--;
1376
1377 if (rdpsnd->references > 0)
1378 return;
1379
1380 rdpsnd_terminate_thread(rdpsnd);
1381 freerdp_dsp_context_free(rdpsnd->dsp_context);
1382 StreamPool_Free(rdpsnd->pool);
1383 rdpsnd->pool = NULL;
1384 rdpsnd->dsp_context = NULL;
1385}
1386
1387static BOOL allocate_internals(rdpsndPlugin* rdpsnd)
1388{
1389 WINPR_ASSERT(rdpsnd);
1390
1391 if (!rdpsnd->pool)
1392 {
1393 rdpsnd->pool = StreamPool_New(TRUE, 4096);
1394 if (!rdpsnd->pool)
1395 return FALSE;
1396 }
1397
1398 if (!rdpsnd->dsp_context)
1399 {
1400 rdpsnd->dsp_context = freerdp_dsp_context_new(FALSE);
1401 if (!rdpsnd->dsp_context)
1402 return FALSE;
1403 }
1404
1405 if (rdpsnd->async)
1406 {
1407 if (!rdpsnd->queue)
1408 {
1409 wObject obj = { 0 };
1410
1411 obj.fnObjectFree = queue_free;
1412 rdpsnd->queue = MessageQueue_New(&obj);
1413 if (!rdpsnd->queue)
1414 return CHANNEL_RC_NO_MEMORY;
1415 }
1416
1417 if (!rdpsnd->thread)
1418 {
1419 rdpsnd->thread = CreateThread(NULL, 0, play_thread, rdpsnd, 0, NULL);
1420 if (!rdpsnd->thread)
1421 return CHANNEL_RC_INITIALIZATION_ERROR;
1422 }
1423 }
1424
1425 rdpsnd->references++;
1426
1427 return TRUE;
1428}
1429
1430static DWORD WINAPI play_thread(LPVOID arg)
1431{
1432 UINT error = CHANNEL_RC_OK;
1433 rdpsndPlugin* rdpsnd = arg;
1434
1435 if (!rdpsnd || !rdpsnd->queue)
1436 return ERROR_INVALID_PARAMETER;
1437
1438 while (TRUE)
1439 {
1440 int rc = -1;
1441 wMessage message = { 0 };
1442 wStream* s = NULL;
1443 DWORD status = 0;
1444 DWORD nCount = 0;
1445 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
1446
1447 handles[nCount++] = MessageQueue_Event(rdpsnd->queue);
1448 handles[nCount++] = freerdp_abort_event(rdpsnd->rdpcontext);
1449 status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
1450 switch (status)
1451 {
1452 case WAIT_OBJECT_0:
1453 break;
1454 default:
1455 return ERROR_TIMEOUT;
1456 }
1457
1458 rc = MessageQueue_Peek(rdpsnd->queue, &message, TRUE);
1459 if (rc < 1)
1460 continue;
1461
1462 if (message.id == WMQ_QUIT)
1463 break;
1464
1465 s = message.wParam;
1466 error = rdpsnd_recv_pdu(rdpsnd, s);
1467
1468 if (error)
1469 return error;
1470 }
1471
1472 return CHANNEL_RC_OK;
1473}
1474
1475static UINT rdpsnd_virtual_channel_event_initialized(rdpsndPlugin* rdpsnd)
1476{
1477 if (!rdpsnd)
1478 return ERROR_INVALID_PARAMETER;
1479
1480 if (!allocate_internals(rdpsnd))
1481 return CHANNEL_RC_NO_MEMORY;
1482
1483 return CHANNEL_RC_OK;
1484}
1485
1486void rdpsnd_virtual_channel_event_terminated(rdpsndPlugin* rdpsnd)
1487{
1488 if (rdpsnd)
1489 {
1490 free_internals(rdpsnd);
1491 audio_formats_free(rdpsnd->fixed_format, 1);
1492 free(rdpsnd->subsystem);
1493 free(rdpsnd->device_name);
1494 rdpsnd->InitHandle = 0;
1495 }
1496
1497 free(rdpsnd);
1498}
1499
1500static VOID VCAPITYPE rdpsnd_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1501 UINT event, LPVOID pData,
1502 UINT dataLength)
1503{
1504 UINT error = CHANNEL_RC_OK;
1505 rdpsndPlugin* plugin = (rdpsndPlugin*)lpUserParam;
1506
1507 if (!plugin)
1508 return;
1509
1510 if (plugin->InitHandle != pInitHandle)
1511 {
1512 WLog_ERR(TAG, "%s error no match", rdpsnd_is_dyn_str(plugin->dynamic));
1513 return;
1514 }
1515
1516 switch (event)
1517 {
1518 case CHANNEL_EVENT_INITIALIZED:
1519 error = rdpsnd_virtual_channel_event_initialized(plugin);
1520 break;
1521
1522 case CHANNEL_EVENT_CONNECTED:
1523 error = rdpsnd_virtual_channel_event_connected(plugin, pData, dataLength);
1524 break;
1525
1526 case CHANNEL_EVENT_DISCONNECTED:
1527 error = rdpsnd_virtual_channel_event_disconnected(plugin);
1528 break;
1529
1530 case CHANNEL_EVENT_TERMINATED:
1531 rdpsnd_virtual_channel_event_terminated(plugin);
1532 plugin = NULL;
1533 break;
1534
1535 case CHANNEL_EVENT_ATTACHED:
1536 plugin->attached = TRUE;
1537 break;
1538
1539 case CHANNEL_EVENT_DETACHED:
1540 plugin->attached = FALSE;
1541 break;
1542
1543 default:
1544 break;
1545 }
1546
1547 if (error && plugin && plugin->rdpcontext)
1548 {
1549 char buffer[8192];
1550 (void)_snprintf(buffer, sizeof(buffer), "%s reported an error",
1551 rdpsnd_is_dyn_str(plugin->dynamic));
1552 setChannelError(plugin->rdpcontext, error, buffer);
1553 }
1554}
1555
1556rdpContext* freerdp_rdpsnd_get_context(rdpsndPlugin* plugin)
1557{
1558 if (!plugin)
1559 return NULL;
1560
1561 return plugin->rdpcontext;
1562}
1563
1564static rdpsndPlugin* allocatePlugin(void)
1565{
1566 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)calloc(1, sizeof(rdpsndPlugin));
1567 if (!rdpsnd)
1568 goto fail;
1569
1570 rdpsnd->fixed_format = audio_format_new();
1571 if (!rdpsnd->fixed_format)
1572 goto fail;
1573 rdpsnd->log = WLog_Get("com.freerdp.channels.rdpsnd.client");
1574 if (!rdpsnd->log)
1575 goto fail;
1576
1577 rdpsnd->attached = TRUE;
1578 return rdpsnd;
1579
1580fail:
1581 if (rdpsnd)
1582 audio_formats_free(rdpsnd->fixed_format, 1);
1583 free(rdpsnd);
1584 return NULL;
1585}
1586/* rdpsnd is always built-in */
1587FREERDP_ENTRY_POINT(BOOL VCAPITYPE rdpsnd_VirtualChannelEntryEx(
1588 PCHANNEL_ENTRY_POINTS_EX pEntryPoints, PVOID pInitHandle))
1589{
1590 UINT rc = 0;
1591 rdpsndPlugin* rdpsnd = NULL;
1592 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = NULL;
1593
1594 if (!pEntryPoints)
1595 return FALSE;
1596
1597 rdpsnd = allocatePlugin();
1598
1599 if (!rdpsnd)
1600 return FALSE;
1601
1602 rdpsnd->channelDef.options = CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP;
1603 (void)sprintf_s(rdpsnd->channelDef.name, ARRAYSIZE(rdpsnd->channelDef.name),
1604 RDPSND_CHANNEL_NAME);
1605 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
1606
1607 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
1608 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
1609 {
1610 rdpsnd->rdpcontext = pEntryPointsEx->context;
1611 if (!freerdp_settings_get_bool(rdpsnd->rdpcontext->settings,
1612 FreeRDP_SynchronousStaticChannels))
1613 rdpsnd->async = TRUE;
1614 }
1615
1616 CopyMemory(&(rdpsnd->channelEntryPoints), pEntryPoints,
1617 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
1618 rdpsnd->InitHandle = pInitHandle;
1619
1620 WINPR_ASSERT(rdpsnd->channelEntryPoints.pVirtualChannelInitEx);
1621 rc = rdpsnd->channelEntryPoints.pVirtualChannelInitEx(
1622 rdpsnd, NULL, pInitHandle, &rdpsnd->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
1623 rdpsnd_virtual_channel_init_event_ex);
1624
1625 if (CHANNEL_RC_OK != rc)
1626 {
1627 WLog_ERR(TAG, "%s pVirtualChannelInitEx failed with %s [%08" PRIX32 "]",
1628 rdpsnd_is_dyn_str(FALSE), WTSErrorToString(rc), rc);
1629 rdpsnd_virtual_channel_event_terminated(rdpsnd);
1630 return FALSE;
1631 }
1632
1633 return TRUE;
1634}
1635
1636static UINT rdpsnd_on_open(IWTSVirtualChannelCallback* pChannelCallback)
1637{
1638 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1639 rdpsndPlugin* rdpsnd = NULL;
1640
1641 WINPR_ASSERT(callback);
1642
1643 rdpsnd = (rdpsndPlugin*)callback->plugin;
1644 WINPR_ASSERT(rdpsnd);
1645
1646 if (rdpsnd->OnOpenCalled)
1647 return CHANNEL_RC_OK;
1648 rdpsnd->OnOpenCalled = TRUE;
1649
1650 if (!allocate_internals(rdpsnd))
1651 return ERROR_OUTOFMEMORY;
1652
1653 return rdpsnd_process_connect(rdpsnd);
1654}
1655
1656static UINT rdpsnd_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
1657{
1658 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1659 rdpsndPlugin* plugin = NULL;
1660 wStream* copy = NULL;
1661 size_t len = 0;
1662
1663 len = Stream_GetRemainingLength(data);
1664
1665 if (!callback || !callback->plugin)
1666 return ERROR_INVALID_PARAMETER;
1667 plugin = (rdpsndPlugin*)callback->plugin;
1668 WINPR_ASSERT(plugin);
1669
1670 copy = StreamPool_Take(plugin->pool, len);
1671 if (!copy)
1672 return ERROR_OUTOFMEMORY;
1673 Stream_Copy(data, copy, len);
1674 Stream_SealLength(copy);
1675 Stream_SetPosition(copy, 0);
1676
1677 if (plugin->async)
1678 {
1679 if (!MessageQueue_Post(plugin->queue, NULL, 0, copy, NULL))
1680 {
1681 Stream_Release(copy);
1682 return ERROR_INTERNAL_ERROR;
1683 }
1684 }
1685 else
1686 {
1687 UINT error = rdpsnd_recv_pdu(plugin, copy);
1688 if (error)
1689 return error;
1690 }
1691
1692 return CHANNEL_RC_OK;
1693}
1694
1695static UINT rdpsnd_on_close(IWTSVirtualChannelCallback* pChannelCallback)
1696{
1697 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1698 rdpsndPlugin* rdpsnd = NULL;
1699
1700 WINPR_ASSERT(callback);
1701
1702 rdpsnd = (rdpsndPlugin*)callback->plugin;
1703 WINPR_ASSERT(rdpsnd);
1704
1705 rdpsnd->OnOpenCalled = FALSE;
1706 if (rdpsnd->device)
1707 IFCALL(rdpsnd->device->Close, rdpsnd->device);
1708
1709 cleanup_internals(rdpsnd);
1710
1711 free_internals(rdpsnd);
1712 if (rdpsnd->device)
1713 {
1714 IFCALL(rdpsnd->device->Free, rdpsnd->device);
1715 rdpsnd->device = NULL;
1716 }
1717
1718 free(pChannelCallback);
1719 return CHANNEL_RC_OK;
1720}
1721
1722// NOLINTBEGIN(readability-non-const-parameter)
1723static UINT rdpsnd_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
1724 IWTSVirtualChannel* pChannel, BYTE* Data,
1725 BOOL* pbAccept,
1726 IWTSVirtualChannelCallback** ppCallback)
1727// NOLINTEND(readability-non-const-parameter)
1728{
1729 GENERIC_CHANNEL_CALLBACK* callback = NULL;
1730 GENERIC_LISTENER_CALLBACK* listener_callback = (GENERIC_LISTENER_CALLBACK*)pListenerCallback;
1731 WINPR_ASSERT(listener_callback);
1732 WINPR_ASSERT(pChannel);
1733 WINPR_ASSERT(ppCallback);
1734 callback = (GENERIC_CHANNEL_CALLBACK*)calloc(1, sizeof(GENERIC_CHANNEL_CALLBACK));
1735
1736 WINPR_UNUSED(Data);
1737 WINPR_UNUSED(pbAccept);
1738
1739 if (!callback)
1740 {
1741 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1742 return CHANNEL_RC_NO_MEMORY;
1743 }
1744
1745 callback->iface.OnOpen = rdpsnd_on_open;
1746 callback->iface.OnDataReceived = rdpsnd_on_data_received;
1747 callback->iface.OnClose = rdpsnd_on_close;
1748 callback->plugin = listener_callback->plugin;
1749 callback->channel_mgr = listener_callback->channel_mgr;
1750 callback->channel = pChannel;
1751 listener_callback->channel_callback = callback;
1752 *ppCallback = &callback->iface;
1753 return CHANNEL_RC_OK;
1754}
1755
1756static UINT rdpsnd_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
1757{
1758 UINT status = 0;
1759 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)pPlugin;
1760 WINPR_ASSERT(rdpsnd);
1761 WINPR_ASSERT(pChannelMgr);
1762 if (rdpsnd->initialized)
1763 {
1764 WLog_ERR(TAG, "[%s] channel initialized twice, aborting", RDPSND_DVC_CHANNEL_NAME);
1765 return ERROR_INVALID_DATA;
1766 }
1767 rdpsnd->listener_callback =
1768 (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
1769
1770 if (!rdpsnd->listener_callback)
1771 {
1772 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1773 return CHANNEL_RC_NO_MEMORY;
1774 }
1775
1776 rdpsnd->listener_callback->iface.OnNewChannelConnection = rdpsnd_on_new_channel_connection;
1777 rdpsnd->listener_callback->plugin = pPlugin;
1778 rdpsnd->listener_callback->channel_mgr = pChannelMgr;
1779 status = pChannelMgr->CreateListener(pChannelMgr, RDPSND_DVC_CHANNEL_NAME, 0,
1780 &rdpsnd->listener_callback->iface, &(rdpsnd->listener));
1781 if (status != CHANNEL_RC_OK)
1782 {
1783 WLog_ERR(TAG, "%s CreateListener failed!", rdpsnd_is_dyn_str(TRUE));
1784 return status;
1785 }
1786
1787 rdpsnd->listener->pInterface = rdpsnd->iface.pInterface;
1788 status = rdpsnd_virtual_channel_event_initialized(rdpsnd);
1789
1790 rdpsnd->initialized = status == CHANNEL_RC_OK;
1791 return status;
1792}
1793
1799static UINT rdpsnd_plugin_terminated(IWTSPlugin* pPlugin)
1800{
1801 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)pPlugin;
1802 if (rdpsnd)
1803 {
1804 if (rdpsnd->listener_callback)
1805 {
1806 IWTSVirtualChannelManager* mgr = rdpsnd->listener_callback->channel_mgr;
1807 if (mgr)
1808 IFCALL(mgr->DestroyListener, mgr, rdpsnd->listener);
1809 }
1810 free(rdpsnd->listener_callback);
1811 free(rdpsnd->iface.pInterface);
1812 }
1813 rdpsnd_virtual_channel_event_terminated(rdpsnd);
1814 return CHANNEL_RC_OK;
1815}
1816
1822FREERDP_ENTRY_POINT(UINT VCAPITYPE rdpsnd_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
1823{
1824 UINT error = CHANNEL_RC_OK;
1825 rdpsndPlugin* rdpsnd = NULL;
1826
1827 WINPR_ASSERT(pEntryPoints);
1828 WINPR_ASSERT(pEntryPoints->GetPlugin);
1829
1830 rdpsnd = (rdpsndPlugin*)pEntryPoints->GetPlugin(pEntryPoints, RDPSND_CHANNEL_NAME);
1831
1832 if (!rdpsnd)
1833 {
1834 IWTSPlugin* iface = NULL;
1835 union
1836 {
1837 const void* cev;
1838 void* ev;
1839 } cnv;
1840
1841 rdpsnd = allocatePlugin();
1842 if (!rdpsnd)
1843 {
1844 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1845 return CHANNEL_RC_NO_MEMORY;
1846 }
1847
1848 iface = &rdpsnd->iface;
1849 iface->Initialize = rdpsnd_plugin_initialize;
1850 iface->Connected = NULL;
1851 iface->Disconnected = NULL;
1852 iface->Terminated = rdpsnd_plugin_terminated;
1853
1854 rdpsnd->dynamic = TRUE;
1855
1856 WINPR_ASSERT(pEntryPoints->GetRdpContext);
1857 rdpsnd->rdpcontext = pEntryPoints->GetRdpContext(pEntryPoints);
1858
1859 if (!freerdp_settings_get_bool(rdpsnd->rdpcontext->settings,
1860 FreeRDP_SynchronousDynamicChannels))
1861 rdpsnd->async = TRUE;
1862
1863 /* user data pointer is not const, cast to avoid warning. */
1864 cnv.cev = pEntryPoints->GetPluginData(pEntryPoints);
1865 WINPR_ASSERT(pEntryPoints->GetPluginData);
1866 rdpsnd->channelEntryPoints.pExtendedData = cnv.ev;
1867
1868 error = pEntryPoints->RegisterPlugin(pEntryPoints, RDPSND_CHANNEL_NAME, iface);
1869 }
1870 else
1871 {
1872 WLog_ERR(TAG, "%s could not get rdpsnd Plugin.", rdpsnd_is_dyn_str(TRUE));
1873 return CHANNEL_RC_BAD_CHANNEL;
1874 }
1875
1876 return error;
1877}
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
ADDIN_ARGV
Definition settings_types.h:373
AUDIO_FORMAT
Definition audio.h:34
CHANNEL_DEF
Definition wtsapi.h:78
CHANNEL_ENTRY_POINTS_FREERDP_EX
Definition svc.h:60
COMMAND_LINE_ARGUMENT_A
Definition winpr/include/winpr/cmdline.h:100
FREERDP_RDPSND_DEVICE_ENTRY_POINTS
Definition client/rdpsnd.h:76
GENERIC_CHANNEL_CALLBACK
Definition include/freerdp/client/channels.h:35
GENERIC_LISTENER_CALLBACK
Definition include/freerdp/client/channels.h:43
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:58