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