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