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 = nullptr;
146 WINPR_ASSERT(rdpsnd);
147 pdu = Stream_New(nullptr, 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 = nullptr;
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 = nullptr;
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(nullptr, 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 = nullptr;
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 = nullptr;
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 = nullptr;
338 WINPR_ASSERT(rdpsnd);
339 pdu = Stream_New(nullptr, 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 = nullptr;
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 = nullptr;
495 WINPR_ASSERT(rdpsnd);
496 pdu = Stream_New(nullptr, 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 = nullptr;
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 = nullptr;
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 = WINPR_C_ARRAY_INIT;
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, nullptr, 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 != nullptr);
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 != nullptr);
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 = nullptr;
904 COMMAND_LINE_ARGUMENT_A rdpsnd_args[] = {
905 { "sys", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", nullptr, nullptr, -1, nullptr,
906 "subsystem" },
907 { "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", nullptr, nullptr, -1, nullptr, "device" },
908 { "format", COMMAND_LINE_VALUE_REQUIRED, "<format>", nullptr, nullptr, -1, nullptr,
909 "format" },
910 { "rate", COMMAND_LINE_VALUE_REQUIRED, "<rate>", nullptr, nullptr, -1, nullptr, "rate" },
911 { "channel", COMMAND_LINE_VALUE_REQUIRED, "<channel>", nullptr, nullptr, -1, nullptr,
912 "channel" },
913 { "latency", COMMAND_LINE_VALUE_REQUIRED, "<latency>", nullptr, nullptr, -1, nullptr,
914 "latency" },
915 { "quality", COMMAND_LINE_VALUE_REQUIRED, "<quality mode>", nullptr, nullptr, -1, nullptr,
916 "quality mode" },
917 { nullptr, 0, nullptr, nullptr, nullptr, -1, nullptr, nullptr }
918 };
919 rdpsnd->wQualityMode = HIGH_QUALITY; /* default quality mode */
920
921 if (args->argc > 1)
922 {
923 flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON;
924 status = CommandLineParseArgumentsA(args->argc, args->argv, rdpsnd_args, flags, rdpsnd,
925 nullptr, nullptr);
926
927 if (status < 0)
928 return CHANNEL_RC_INITIALIZATION_ERROR;
929
930 arg = rdpsnd_args;
931 errno = 0;
932
933 do
934 {
935 if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
936 continue;
937
938 CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "sys")
939 {
940 if (!rdpsnd_set_subsystem(rdpsnd, arg->Value))
941 return CHANNEL_RC_NO_MEMORY;
942 }
943 CommandLineSwitchCase(arg, "dev")
944 {
945 if (!rdpsnd_set_device_name(rdpsnd, arg->Value))
946 return CHANNEL_RC_NO_MEMORY;
947 }
948 CommandLineSwitchCase(arg, "format")
949 {
950 unsigned long val = strtoul(arg->Value, nullptr, 0);
951
952 if ((errno != 0) || (val > UINT16_MAX))
953 return CHANNEL_RC_INITIALIZATION_ERROR;
954
955 rdpsnd->fixed_format->wFormatTag = (UINT16)val;
956 }
957 CommandLineSwitchCase(arg, "rate")
958 {
959 unsigned long val = strtoul(arg->Value, nullptr, 0);
960
961 if ((errno != 0) || (val > UINT32_MAX))
962 return CHANNEL_RC_INITIALIZATION_ERROR;
963
964 rdpsnd->fixed_format->nSamplesPerSec = (UINT32)val;
965 }
966 CommandLineSwitchCase(arg, "channel")
967 {
968 unsigned long val = strtoul(arg->Value, nullptr, 0);
969
970 if ((errno != 0) || (val > UINT16_MAX))
971 return CHANNEL_RC_INITIALIZATION_ERROR;
972
973 rdpsnd->fixed_format->nChannels = (UINT16)val;
974 }
975 CommandLineSwitchCase(arg, "latency")
976 {
977 unsigned long val = strtoul(arg->Value, nullptr, 0);
978
979 if ((errno != 0) || (val > UINT32_MAX))
980 return CHANNEL_RC_INITIALIZATION_ERROR;
981
982 rdpsnd->latency = (UINT32)val;
983 }
984 CommandLineSwitchCase(arg, "quality")
985 {
986 long wQualityMode = DYNAMIC_QUALITY;
987
988 if (_stricmp(arg->Value, "dynamic") == 0)
989 wQualityMode = DYNAMIC_QUALITY;
990 else if (_stricmp(arg->Value, "medium") == 0)
991 wQualityMode = MEDIUM_QUALITY;
992 else if (_stricmp(arg->Value, "high") == 0)
993 wQualityMode = HIGH_QUALITY;
994 else
995 {
996 wQualityMode = strtol(arg->Value, nullptr, 0);
997
998 if (errno != 0)
999 return CHANNEL_RC_INITIALIZATION_ERROR;
1000 }
1001
1002 if ((wQualityMode < 0) || (wQualityMode > 2))
1003 wQualityMode = DYNAMIC_QUALITY;
1004
1005 rdpsnd->wQualityMode = (UINT16)wQualityMode;
1006 }
1007 CommandLineSwitchDefault(arg)
1008 {
1009 }
1010 CommandLineSwitchEnd(arg)
1011 } while ((arg = CommandLineFindNextArgumentA(arg)) != nullptr);
1012 }
1013
1014 return CHANNEL_RC_OK;
1015}
1016
1022static UINT rdpsnd_process_connect(rdpsndPlugin* rdpsnd)
1023{
1024 const struct
1025 {
1026 const char* subsystem;
1027 const char* device;
1028 } backends[] = {
1029#if defined(WITH_IOSAUDIO)
1030 { "ios", "" },
1031#endif
1032#if defined(WITH_OPENSLES)
1033 { "opensles", "" },
1034#endif
1035#if defined(WITH_PULSE)
1036 { "pulse", "" },
1037#endif
1038#if defined(WITH_ALSA)
1039 { "alsa", "default" },
1040#endif
1041#if defined(WITH_OSS)
1042 { "oss", "" },
1043#endif
1044#if defined(WITH_MACAUDIO)
1045 { "mac", "default" },
1046#endif
1047#if defined(WITH_WINMM)
1048 { "winmm", "" },
1049#endif
1050#if defined(WITH_SNDIO)
1051 { "sndio", "" },
1052#endif
1053 { "fake", "" }
1054 };
1055 const ADDIN_ARGV* args = nullptr;
1056 UINT status = ERROR_INTERNAL_ERROR;
1057 WINPR_ASSERT(rdpsnd);
1058 rdpsnd->latency = 0;
1059 args = (const ADDIN_ARGV*)rdpsnd->channelEntryPoints.pExtendedData;
1060
1061 if (args)
1062 {
1063 status = rdpsnd_process_addin_args(rdpsnd, args);
1064
1065 if (status != CHANNEL_RC_OK)
1066 return status;
1067 }
1068
1069 if (rdpsnd->subsystem)
1070 {
1071 if ((status = rdpsnd_load_device_plugin(rdpsnd, rdpsnd->subsystem, args)))
1072 {
1073 WLog_ERR(TAG,
1074 "%s Unable to load sound playback subsystem %s because of error %" PRIu32 "",
1075 rdpsnd_is_dyn_str(rdpsnd->dynamic), rdpsnd->subsystem, status);
1076 return status;
1077 }
1078 }
1079 else
1080 {
1081 for (size_t x = 0; x < ARRAYSIZE(backends); x++)
1082 {
1083 const char* subsystem_name = backends[x].subsystem;
1084 const char* device_name = backends[x].device;
1085
1086 if ((status = rdpsnd_load_device_plugin(rdpsnd, subsystem_name, args)))
1087 WLog_ERR(TAG,
1088 "%s Unable to load sound playback subsystem %s because of error %" PRIu32
1089 "",
1090 rdpsnd_is_dyn_str(rdpsnd->dynamic), subsystem_name, status);
1091
1092 if (!rdpsnd->device)
1093 continue;
1094
1095 if (!rdpsnd_set_subsystem(rdpsnd, subsystem_name) ||
1096 !rdpsnd_set_device_name(rdpsnd, device_name))
1097 return CHANNEL_RC_NO_MEMORY;
1098
1099 break;
1100 }
1101
1102 if (!rdpsnd->device || status)
1103 return CHANNEL_RC_INITIALIZATION_ERROR;
1104 }
1105
1106 return CHANNEL_RC_OK;
1107}
1108
1114UINT rdpsnd_virtual_channel_write(rdpsndPlugin* rdpsnd, wStream* s)
1115{
1116 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
1117
1118 if (rdpsnd)
1119 {
1120 if (rdpsnd->dynamic)
1121 {
1122 IWTSVirtualChannel* channel = nullptr;
1123 if (rdpsnd->listener_callback)
1124 {
1125 channel = rdpsnd->listener_callback->channel_callback->channel;
1126 status =
1127 channel->Write(channel, (UINT32)Stream_Length(s), Stream_Buffer(s), nullptr);
1128 }
1129 Stream_Free(s, TRUE);
1130 }
1131 else
1132 {
1133 status = rdpsnd->channelEntryPoints.pVirtualChannelWriteEx(
1134 rdpsnd->InitHandle, rdpsnd->OpenHandle, Stream_Buffer(s),
1135 (UINT32)Stream_GetPosition(s), s);
1136
1137 if (status != CHANNEL_RC_OK)
1138 {
1139 Stream_Free(s, TRUE);
1140 WLog_ERR(TAG, "%s pVirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1141 rdpsnd_is_dyn_str(FALSE), WTSErrorToString(status), status);
1142 }
1143 }
1144 }
1145
1146 return status;
1147}
1148
1154static UINT rdpsnd_virtual_channel_event_data_received(rdpsndPlugin* plugin, void* pData,
1155 UINT32 dataLength, UINT32 totalLength,
1156 UINT32 dataFlags)
1157{
1158 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1159 return CHANNEL_RC_OK;
1160
1161 if (dataFlags & CHANNEL_FLAG_FIRST)
1162 {
1163 if (!plugin->data_in)
1164 plugin->data_in = StreamPool_Take(plugin->pool, totalLength);
1165
1166 Stream_SetPosition(plugin->data_in, 0);
1167 }
1168
1169 if (!Stream_EnsureRemainingCapacity(plugin->data_in, dataLength))
1170 return CHANNEL_RC_NO_MEMORY;
1171
1172 Stream_Write(plugin->data_in, pData, dataLength);
1173
1174 if (dataFlags & CHANNEL_FLAG_LAST)
1175 {
1176 Stream_SealLength(plugin->data_in);
1177 Stream_SetPosition(plugin->data_in, 0);
1178
1179 if (plugin->async)
1180 {
1181 if (!MessageQueue_Post(plugin->queue, nullptr, 0, plugin->data_in, nullptr))
1182 return ERROR_INTERNAL_ERROR;
1183 plugin->data_in = nullptr;
1184 }
1185 else
1186 {
1187 UINT error = rdpsnd_recv_pdu(plugin, plugin->data_in);
1188 plugin->data_in = nullptr;
1189 if (error)
1190 return error;
1191 }
1192 }
1193
1194 return CHANNEL_RC_OK;
1195}
1196
1197static VOID VCAPITYPE rdpsnd_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1198 UINT event, LPVOID pData,
1199 UINT32 dataLength, UINT32 totalLength,
1200 UINT32 dataFlags)
1201{
1202 UINT error = CHANNEL_RC_OK;
1203 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)lpUserParam;
1204 WINPR_ASSERT(rdpsnd);
1205 WINPR_ASSERT(!rdpsnd->dynamic);
1206
1207 switch (event)
1208 {
1209 case CHANNEL_EVENT_DATA_RECEIVED:
1210 if (!rdpsnd)
1211 return;
1212
1213 if (rdpsnd->OpenHandle != openHandle)
1214 {
1215 WLog_ERR(TAG, "%s error no match", rdpsnd_is_dyn_str(rdpsnd->dynamic));
1216 return;
1217 }
1218 if ((error = rdpsnd_virtual_channel_event_data_received(rdpsnd, pData, dataLength,
1219 totalLength, dataFlags)))
1220 WLog_ERR(TAG,
1221 "%s rdpsnd_virtual_channel_event_data_received failed with error %" PRIu32
1222 "",
1223 rdpsnd_is_dyn_str(rdpsnd->dynamic), error);
1224
1225 break;
1226
1227 case CHANNEL_EVENT_WRITE_CANCELLED:
1228 case CHANNEL_EVENT_WRITE_COMPLETE:
1229 {
1230 wStream* s = (wStream*)pData;
1231 Stream_Free(s, TRUE);
1232 }
1233 break;
1234
1235 case CHANNEL_EVENT_USER:
1236 break;
1237 default:
1238 break;
1239 }
1240
1241 if (error && rdpsnd && rdpsnd->rdpcontext)
1242 {
1243 char buffer[8192];
1244 (void)_snprintf(buffer, sizeof(buffer),
1245 "%s rdpsnd_virtual_channel_open_event_ex reported an error",
1246 rdpsnd_is_dyn_str(rdpsnd->dynamic));
1247 setChannelError(rdpsnd->rdpcontext, error, buffer);
1248 }
1249}
1250
1256static UINT rdpsnd_virtual_channel_event_connected(rdpsndPlugin* rdpsnd, LPVOID pData,
1257 UINT32 dataLength)
1258{
1259 UINT32 status = 0;
1260 DWORD opened = 0;
1261 WINPR_UNUSED(pData);
1262 WINPR_UNUSED(dataLength);
1263
1264 WINPR_ASSERT(rdpsnd);
1265 WINPR_ASSERT(!rdpsnd->dynamic);
1266
1267 status = rdpsnd->channelEntryPoints.pVirtualChannelOpenEx(
1268 rdpsnd->InitHandle, &opened, rdpsnd->channelDef.name, rdpsnd_virtual_channel_open_event_ex);
1269
1270 if (status != CHANNEL_RC_OK)
1271 {
1272 WLog_ERR(TAG, "%s pVirtualChannelOpenEx failed with %s [%08" PRIX32 "]",
1273 rdpsnd_is_dyn_str(rdpsnd->dynamic), WTSErrorToString(status), status);
1274 goto fail;
1275 }
1276
1277 if (rdpsnd_process_connect(rdpsnd) != CHANNEL_RC_OK)
1278 goto fail;
1279
1280 rdpsnd->OpenHandle = opened;
1281 return CHANNEL_RC_OK;
1282fail:
1283 if (opened != 0)
1284 rdpsnd->channelEntryPoints.pVirtualChannelCloseEx(rdpsnd->InitHandle, opened);
1285 return CHANNEL_RC_NO_MEMORY;
1286}
1287
1288static void rdpsnd_terminate_thread(rdpsndPlugin* rdpsnd)
1289{
1290 WINPR_ASSERT(rdpsnd);
1291 if (rdpsnd->queue)
1292 MessageQueue_PostQuit(rdpsnd->queue, 0);
1293
1294 if (rdpsnd->thread)
1295 {
1296 (void)WaitForSingleObject(rdpsnd->thread, INFINITE);
1297 (void)CloseHandle(rdpsnd->thread);
1298 }
1299
1300 MessageQueue_Free(rdpsnd->queue);
1301 rdpsnd->thread = nullptr;
1302 rdpsnd->queue = nullptr;
1303}
1304
1305static void cleanup_internals(rdpsndPlugin* rdpsnd)
1306{
1307 if (!rdpsnd)
1308 return;
1309
1310 if (rdpsnd->pool)
1311 StreamPool_Return(rdpsnd->pool, rdpsnd->data_in);
1312
1313 audio_formats_free(rdpsnd->ClientFormats, rdpsnd->NumberOfClientFormats);
1314 audio_formats_free(rdpsnd->ServerFormats, rdpsnd->NumberOfServerFormats);
1315
1316 rdpsnd->NumberOfClientFormats = 0;
1317 rdpsnd->ClientFormats = nullptr;
1318 rdpsnd->NumberOfServerFormats = 0;
1319 rdpsnd->ServerFormats = nullptr;
1320
1321 rdpsnd->data_in = nullptr;
1322}
1323
1329static UINT rdpsnd_virtual_channel_event_disconnected(rdpsndPlugin* rdpsnd)
1330{
1331 UINT error = 0;
1332
1333 WINPR_ASSERT(rdpsnd);
1334 WINPR_ASSERT(!rdpsnd->dynamic);
1335 if (rdpsnd->OpenHandle != 0)
1336 {
1337 DWORD opened = rdpsnd->OpenHandle;
1338 rdpsnd->OpenHandle = 0;
1339 if (rdpsnd->device)
1340 IFCALL(rdpsnd->device->Close, rdpsnd->device);
1341
1342 error = rdpsnd->channelEntryPoints.pVirtualChannelCloseEx(rdpsnd->InitHandle, opened);
1343
1344 if (CHANNEL_RC_OK != error)
1345 {
1346 WLog_ERR(TAG, "%s pVirtualChannelCloseEx failed with %s [%08" PRIX32 "]",
1347 rdpsnd_is_dyn_str(rdpsnd->dynamic), WTSErrorToString(error), error);
1348 return error;
1349 }
1350 }
1351
1352 cleanup_internals(rdpsnd);
1353
1354 if (rdpsnd->device)
1355 {
1356 IFCALL(rdpsnd->device->Free, rdpsnd->device);
1357 rdpsnd->device = nullptr;
1358 }
1359
1360 return CHANNEL_RC_OK;
1361}
1362
1363static void queue_free(void* obj)
1364{
1365 wMessage* msg = obj;
1366 if (!msg)
1367 return;
1368 if (msg->id != 0)
1369 return;
1370 wStream* s = msg->wParam;
1371 Stream_Release(s);
1372}
1373
1374static void free_internals(rdpsndPlugin* rdpsnd)
1375{
1376 if (!rdpsnd)
1377 return;
1378
1379 if (rdpsnd->references > 0)
1380 rdpsnd->references--;
1381
1382 if (rdpsnd->references > 0)
1383 return;
1384
1385 rdpsnd_terminate_thread(rdpsnd);
1386 freerdp_dsp_context_free(rdpsnd->dsp_context);
1387 StreamPool_Free(rdpsnd->pool);
1388 rdpsnd->pool = nullptr;
1389 rdpsnd->dsp_context = nullptr;
1390}
1391
1392static BOOL allocate_internals(rdpsndPlugin* rdpsnd)
1393{
1394 WINPR_ASSERT(rdpsnd);
1395
1396 if (!rdpsnd->pool)
1397 {
1398 rdpsnd->pool = StreamPool_New(TRUE, 4096);
1399 if (!rdpsnd->pool)
1400 return FALSE;
1401 }
1402
1403 if (!rdpsnd->dsp_context)
1404 {
1405 rdpsnd->dsp_context = freerdp_dsp_context_new(FALSE);
1406 if (!rdpsnd->dsp_context)
1407 return FALSE;
1408 }
1409
1410 if (rdpsnd->async)
1411 {
1412 if (!rdpsnd->queue)
1413 {
1414 wObject obj = WINPR_C_ARRAY_INIT;
1415
1416 obj.fnObjectFree = queue_free;
1417 rdpsnd->queue = MessageQueue_New(&obj);
1418 if (!rdpsnd->queue)
1419 return CHANNEL_RC_NO_MEMORY;
1420 }
1421
1422 if (!rdpsnd->thread)
1423 {
1424 rdpsnd->thread = CreateThread(nullptr, 0, play_thread, rdpsnd, 0, nullptr);
1425 if (!rdpsnd->thread)
1426 return CHANNEL_RC_INITIALIZATION_ERROR;
1427 }
1428 }
1429
1430 rdpsnd->references++;
1431
1432 return TRUE;
1433}
1434
1435static DWORD WINAPI play_thread(LPVOID arg)
1436{
1437 UINT error = CHANNEL_RC_OK;
1438 rdpsndPlugin* rdpsnd = arg;
1439
1440 if (!rdpsnd || !rdpsnd->queue)
1441 return ERROR_INVALID_PARAMETER;
1442
1443 while (TRUE)
1444 {
1445 int rc = -1;
1446 wMessage message = WINPR_C_ARRAY_INIT;
1447 wStream* s = nullptr;
1448 DWORD status = 0;
1449 DWORD nCount = 0;
1450 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = WINPR_C_ARRAY_INIT;
1451
1452 handles[nCount++] = MessageQueue_Event(rdpsnd->queue);
1453 handles[nCount++] = freerdp_abort_event(rdpsnd->rdpcontext);
1454 status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
1455 switch (status)
1456 {
1457 case WAIT_OBJECT_0:
1458 break;
1459 default:
1460 return ERROR_TIMEOUT;
1461 }
1462
1463 rc = MessageQueue_Peek(rdpsnd->queue, &message, TRUE);
1464 if (rc < 1)
1465 continue;
1466
1467 if (message.id == WMQ_QUIT)
1468 break;
1469
1470 s = message.wParam;
1471 error = rdpsnd_recv_pdu(rdpsnd, s);
1472
1473 if (error)
1474 return error;
1475 }
1476
1477 return CHANNEL_RC_OK;
1478}
1479
1480static UINT rdpsnd_virtual_channel_event_initialized(rdpsndPlugin* rdpsnd)
1481{
1482 if (!rdpsnd)
1483 return ERROR_INVALID_PARAMETER;
1484
1485 if (!allocate_internals(rdpsnd))
1486 return CHANNEL_RC_NO_MEMORY;
1487
1488 return CHANNEL_RC_OK;
1489}
1490
1491void rdpsnd_virtual_channel_event_terminated(rdpsndPlugin* rdpsnd)
1492{
1493 if (rdpsnd)
1494 {
1495 free_internals(rdpsnd);
1496 audio_formats_free(rdpsnd->fixed_format, 1);
1497 free(rdpsnd->subsystem);
1498 free(rdpsnd->device_name);
1499 rdpsnd->InitHandle = nullptr;
1500 }
1501
1502 free(rdpsnd);
1503}
1504
1505static VOID VCAPITYPE rdpsnd_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1506 UINT event, LPVOID pData,
1507 UINT dataLength)
1508{
1509 UINT error = CHANNEL_RC_OK;
1510 rdpsndPlugin* plugin = (rdpsndPlugin*)lpUserParam;
1511
1512 if (!plugin)
1513 return;
1514
1515 if (plugin->InitHandle != pInitHandle)
1516 {
1517 WLog_ERR(TAG, "%s error no match", rdpsnd_is_dyn_str(plugin->dynamic));
1518 return;
1519 }
1520
1521 switch (event)
1522 {
1523 case CHANNEL_EVENT_INITIALIZED:
1524 error = rdpsnd_virtual_channel_event_initialized(plugin);
1525 break;
1526
1527 case CHANNEL_EVENT_CONNECTED:
1528 error = rdpsnd_virtual_channel_event_connected(plugin, pData, dataLength);
1529 break;
1530
1531 case CHANNEL_EVENT_DISCONNECTED:
1532 error = rdpsnd_virtual_channel_event_disconnected(plugin);
1533 break;
1534
1535 case CHANNEL_EVENT_TERMINATED:
1536 rdpsnd_virtual_channel_event_terminated(plugin);
1537 plugin = nullptr;
1538 break;
1539
1540 case CHANNEL_EVENT_ATTACHED:
1541 plugin->attached = TRUE;
1542 break;
1543
1544 case CHANNEL_EVENT_DETACHED:
1545 plugin->attached = FALSE;
1546 break;
1547
1548 default:
1549 break;
1550 }
1551
1552 if (error && plugin && plugin->rdpcontext)
1553 {
1554 char buffer[8192];
1555 (void)_snprintf(buffer, sizeof(buffer), "%s reported an error",
1556 rdpsnd_is_dyn_str(plugin->dynamic));
1557 setChannelError(plugin->rdpcontext, error, buffer);
1558 }
1559}
1560
1561rdpContext* freerdp_rdpsnd_get_context(rdpsndPlugin* plugin)
1562{
1563 if (!plugin)
1564 return nullptr;
1565
1566 return plugin->rdpcontext;
1567}
1568
1569static rdpsndPlugin* allocatePlugin(void)
1570{
1571 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)calloc(1, sizeof(rdpsndPlugin));
1572 if (!rdpsnd)
1573 goto fail;
1574
1575 rdpsnd->fixed_format = audio_format_new();
1576 if (!rdpsnd->fixed_format)
1577 goto fail;
1578 rdpsnd->log = WLog_Get("com.freerdp.channels.rdpsnd.client");
1579 if (!rdpsnd->log)
1580 goto fail;
1581
1582 rdpsnd->attached = TRUE;
1583 return rdpsnd;
1584
1585fail:
1586 if (rdpsnd)
1587 audio_formats_free(rdpsnd->fixed_format, 1);
1588 free(rdpsnd);
1589 return nullptr;
1590}
1591/* rdpsnd is always built-in */
1592FREERDP_ENTRY_POINT(BOOL VCAPITYPE rdpsnd_VirtualChannelEntryEx(
1593 PCHANNEL_ENTRY_POINTS_EX pEntryPoints, PVOID pInitHandle))
1594{
1595 UINT rc = 0;
1596 rdpsndPlugin* rdpsnd = nullptr;
1597 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = nullptr;
1598
1599 if (!pEntryPoints)
1600 return FALSE;
1601
1602 rdpsnd = allocatePlugin();
1603
1604 if (!rdpsnd)
1605 return FALSE;
1606
1607 rdpsnd->channelDef.options = CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP;
1608 (void)sprintf_s(rdpsnd->channelDef.name, ARRAYSIZE(rdpsnd->channelDef.name),
1609 RDPSND_CHANNEL_NAME);
1610 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
1611
1612 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
1613 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
1614 {
1615 rdpsnd->rdpcontext = pEntryPointsEx->context;
1616 if (!freerdp_settings_get_bool(rdpsnd->rdpcontext->settings,
1617 FreeRDP_SynchronousStaticChannels))
1618 rdpsnd->async = TRUE;
1619 }
1620
1621 CopyMemory(&(rdpsnd->channelEntryPoints), pEntryPoints,
1622 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
1623 rdpsnd->InitHandle = pInitHandle;
1624
1625 WINPR_ASSERT(rdpsnd->channelEntryPoints.pVirtualChannelInitEx);
1626 rc = rdpsnd->channelEntryPoints.pVirtualChannelInitEx(
1627 rdpsnd, nullptr, pInitHandle, &rdpsnd->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
1628 rdpsnd_virtual_channel_init_event_ex);
1629
1630 if (CHANNEL_RC_OK != rc)
1631 {
1632 WLog_ERR(TAG, "%s pVirtualChannelInitEx failed with %s [%08" PRIX32 "]",
1633 rdpsnd_is_dyn_str(FALSE), WTSErrorToString(rc), rc);
1634 rdpsnd_virtual_channel_event_terminated(rdpsnd);
1635 return FALSE;
1636 }
1637
1638 return TRUE;
1639}
1640
1641static UINT rdpsnd_on_open(IWTSVirtualChannelCallback* pChannelCallback)
1642{
1643 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1644 rdpsndPlugin* rdpsnd = nullptr;
1645
1646 WINPR_ASSERT(callback);
1647
1648 rdpsnd = (rdpsndPlugin*)callback->plugin;
1649 WINPR_ASSERT(rdpsnd);
1650
1651 if (rdpsnd->OnOpenCalled)
1652 return CHANNEL_RC_OK;
1653 rdpsnd->OnOpenCalled = TRUE;
1654
1655 if (!allocate_internals(rdpsnd))
1656 return ERROR_OUTOFMEMORY;
1657
1658 return rdpsnd_process_connect(rdpsnd);
1659}
1660
1661static UINT rdpsnd_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
1662{
1663 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1664 rdpsndPlugin* plugin = nullptr;
1665 wStream* copy = nullptr;
1666 size_t len = 0;
1667
1668 len = Stream_GetRemainingLength(data);
1669
1670 if (!callback || !callback->plugin)
1671 return ERROR_INVALID_PARAMETER;
1672 plugin = (rdpsndPlugin*)callback->plugin;
1673 WINPR_ASSERT(plugin);
1674
1675 copy = StreamPool_Take(plugin->pool, len);
1676 if (!copy)
1677 return ERROR_OUTOFMEMORY;
1678 Stream_Copy(data, copy, len);
1679 Stream_SealLength(copy);
1680 Stream_SetPosition(copy, 0);
1681
1682 if (plugin->async)
1683 {
1684 if (!MessageQueue_Post(plugin->queue, nullptr, 0, copy, nullptr))
1685 {
1686 Stream_Release(copy);
1687 return ERROR_INTERNAL_ERROR;
1688 }
1689 }
1690 else
1691 {
1692 UINT error = rdpsnd_recv_pdu(plugin, copy);
1693 if (error)
1694 return error;
1695 }
1696
1697 return CHANNEL_RC_OK;
1698}
1699
1700static UINT rdpsnd_on_close(IWTSVirtualChannelCallback* pChannelCallback)
1701{
1702 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
1703 rdpsndPlugin* rdpsnd = nullptr;
1704
1705 WINPR_ASSERT(callback);
1706
1707 rdpsnd = (rdpsndPlugin*)callback->plugin;
1708 WINPR_ASSERT(rdpsnd);
1709
1710 rdpsnd->OnOpenCalled = FALSE;
1711 if (rdpsnd->device)
1712 IFCALL(rdpsnd->device->Close, rdpsnd->device);
1713
1714 cleanup_internals(rdpsnd);
1715
1716 free_internals(rdpsnd);
1717 if (rdpsnd->device)
1718 {
1719 IFCALL(rdpsnd->device->Free, rdpsnd->device);
1720 rdpsnd->device = nullptr;
1721 }
1722
1723 free(pChannelCallback);
1724 return CHANNEL_RC_OK;
1725}
1726
1727// NOLINTBEGIN(readability-non-const-parameter)
1728static UINT rdpsnd_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
1729 IWTSVirtualChannel* pChannel, BYTE* Data,
1730 BOOL* pbAccept,
1731 IWTSVirtualChannelCallback** ppCallback)
1732// NOLINTEND(readability-non-const-parameter)
1733{
1734 GENERIC_CHANNEL_CALLBACK* callback = nullptr;
1735 GENERIC_LISTENER_CALLBACK* listener_callback = (GENERIC_LISTENER_CALLBACK*)pListenerCallback;
1736 WINPR_ASSERT(listener_callback);
1737 WINPR_ASSERT(pChannel);
1738 WINPR_ASSERT(ppCallback);
1739 callback = (GENERIC_CHANNEL_CALLBACK*)calloc(1, sizeof(GENERIC_CHANNEL_CALLBACK));
1740
1741 WINPR_UNUSED(Data);
1742 WINPR_UNUSED(pbAccept);
1743
1744 if (!callback)
1745 {
1746 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1747 return CHANNEL_RC_NO_MEMORY;
1748 }
1749
1750 callback->iface.OnOpen = rdpsnd_on_open;
1751 callback->iface.OnDataReceived = rdpsnd_on_data_received;
1752 callback->iface.OnClose = rdpsnd_on_close;
1753 callback->plugin = listener_callback->plugin;
1754 callback->channel_mgr = listener_callback->channel_mgr;
1755 callback->channel = pChannel;
1756 listener_callback->channel_callback = callback;
1757 *ppCallback = &callback->iface;
1758 return CHANNEL_RC_OK;
1759}
1760
1761static UINT rdpsnd_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
1762{
1763 UINT status = 0;
1764 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)pPlugin;
1765 WINPR_ASSERT(rdpsnd);
1766 WINPR_ASSERT(pChannelMgr);
1767 if (rdpsnd->initialized)
1768 {
1769 WLog_ERR(TAG, "[%s] channel initialized twice, aborting", RDPSND_DVC_CHANNEL_NAME);
1770 return ERROR_INVALID_DATA;
1771 }
1772 rdpsnd->listener_callback =
1773 (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
1774
1775 if (!rdpsnd->listener_callback)
1776 {
1777 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1778 return CHANNEL_RC_NO_MEMORY;
1779 }
1780
1781 rdpsnd->listener_callback->iface.OnNewChannelConnection = rdpsnd_on_new_channel_connection;
1782 rdpsnd->listener_callback->plugin = pPlugin;
1783 rdpsnd->listener_callback->channel_mgr = pChannelMgr;
1784 status = pChannelMgr->CreateListener(pChannelMgr, RDPSND_DVC_CHANNEL_NAME, 0,
1785 &rdpsnd->listener_callback->iface, &(rdpsnd->listener));
1786 if (status != CHANNEL_RC_OK)
1787 {
1788 WLog_ERR(TAG, "%s CreateListener failed!", rdpsnd_is_dyn_str(TRUE));
1789 return status;
1790 }
1791
1792 rdpsnd->listener->pInterface = rdpsnd->iface.pInterface;
1793 status = rdpsnd_virtual_channel_event_initialized(rdpsnd);
1794
1795 rdpsnd->initialized = status == CHANNEL_RC_OK;
1796 return status;
1797}
1798
1804static UINT rdpsnd_plugin_terminated(IWTSPlugin* pPlugin)
1805{
1806 rdpsndPlugin* rdpsnd = (rdpsndPlugin*)pPlugin;
1807 if (rdpsnd)
1808 {
1809 if (rdpsnd->listener_callback)
1810 {
1811 IWTSVirtualChannelManager* mgr = rdpsnd->listener_callback->channel_mgr;
1812 if (mgr)
1813 IFCALL(mgr->DestroyListener, mgr, rdpsnd->listener);
1814 }
1815 free(rdpsnd->listener_callback);
1816 free(rdpsnd->iface.pInterface);
1817 }
1818 rdpsnd_virtual_channel_event_terminated(rdpsnd);
1819 return CHANNEL_RC_OK;
1820}
1821
1827FREERDP_ENTRY_POINT(UINT VCAPITYPE rdpsnd_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
1828{
1829 UINT error = CHANNEL_RC_OK;
1830 rdpsndPlugin* rdpsnd = nullptr;
1831
1832 WINPR_ASSERT(pEntryPoints);
1833 WINPR_ASSERT(pEntryPoints->GetPlugin);
1834
1835 rdpsnd = (rdpsndPlugin*)pEntryPoints->GetPlugin(pEntryPoints, RDPSND_CHANNEL_NAME);
1836
1837 if (!rdpsnd)
1838 {
1839 IWTSPlugin* iface = nullptr;
1840 union
1841 {
1842 const void* cev;
1843 void* ev;
1844 } cnv;
1845
1846 rdpsnd = allocatePlugin();
1847 if (!rdpsnd)
1848 {
1849 WLog_ERR(TAG, "%s calloc failed!", rdpsnd_is_dyn_str(TRUE));
1850 return CHANNEL_RC_NO_MEMORY;
1851 }
1852
1853 iface = &rdpsnd->iface;
1854 iface->Initialize = rdpsnd_plugin_initialize;
1855 iface->Connected = nullptr;
1856 iface->Disconnected = nullptr;
1857 iface->Terminated = rdpsnd_plugin_terminated;
1858
1859 rdpsnd->dynamic = TRUE;
1860
1861 WINPR_ASSERT(pEntryPoints->GetRdpContext);
1862 rdpsnd->rdpcontext = pEntryPoints->GetRdpContext(pEntryPoints);
1863
1864 if (!freerdp_settings_get_bool(rdpsnd->rdpcontext->settings,
1865 FreeRDP_SynchronousDynamicChannels))
1866 rdpsnd->async = TRUE;
1867
1868 /* user data pointer is not const, cast to avoid warning. */
1869 cnv.cev = pEntryPoints->GetPluginData(pEntryPoints);
1870 WINPR_ASSERT(pEntryPoints->GetPluginData);
1871 rdpsnd->channelEntryPoints.pExtendedData = cnv.ev;
1872
1873 error = pEntryPoints->RegisterPlugin(pEntryPoints, RDPSND_CHANNEL_NAME, iface);
1874 }
1875 else
1876 {
1877 WLog_ERR(TAG, "%s could not get rdpsnd Plugin.", rdpsnd_is_dyn_str(TRUE));
1878 return CHANNEL_RC_BAD_CHANNEL;
1879 }
1880
1881 return error;
1882}
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:375
AUDIO_FORMAT
Definition audio.h:35
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