FreeRDP
Loading...
Searching...
No Matches
server/rdpsnd_main.c
1
22#include <freerdp/config.h>
23
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27
28#include <winpr/crt.h>
29#include <winpr/assert.h>
30#include <winpr/cast.h>
31#include <winpr/print.h>
32#include <winpr/stream.h>
33
34#include <freerdp/freerdp.h>
35#include <freerdp/channels/log.h>
36
37#include "rdpsnd_common.h"
38#include "rdpsnd_main.h"
39
40static wStream* rdpsnd_server_get_buffer(RdpsndServerContext* context)
41{
42 wStream* s = NULL;
43 WINPR_ASSERT(context);
44 WINPR_ASSERT(context->priv);
45
46 s = context->priv->rdpsnd_pdu;
47 Stream_SetPosition(s, 0);
48 return s;
49}
50
56static UINT rdpsnd_server_send_formats(RdpsndServerContext* context)
57{
58 wStream* s = rdpsnd_server_get_buffer(context);
59 BOOL status = FALSE;
60 ULONG written = 0;
61
62 if (!Stream_EnsureRemainingCapacity(s, 24))
63 return ERROR_OUTOFMEMORY;
64
65 Stream_Write_UINT8(s, SNDC_FORMATS);
66 Stream_Write_UINT8(s, 0);
67 Stream_Seek_UINT16(s);
68 Stream_Write_UINT32(s, 0); /* dwFlags */
69 Stream_Write_UINT32(s, 0); /* dwVolume */
70 Stream_Write_UINT32(s, 0); /* dwPitch */
71 Stream_Write_UINT16(s, 0); /* wDGramPort */
72 Stream_Write_UINT16(
73 s, WINPR_ASSERTING_INT_CAST(uint16_t, context->num_server_formats)); /* wNumberOfFormats */
74 Stream_Write_UINT8(s, context->block_no); /* cLastBlockConfirmed */
75 Stream_Write_UINT16(s, CHANNEL_VERSION_WIN_MAX); /* wVersion */
76 Stream_Write_UINT8(s, 0); /* bPad */
77
78 for (size_t i = 0; i < context->num_server_formats; i++)
79 {
80 const AUDIO_FORMAT* format = &context->server_formats[i];
81
82 if (!audio_format_write(s, format))
83 goto fail;
84 }
85
86 {
87 const size_t pos = Stream_GetPosition(s);
88 if (pos > UINT16_MAX)
89 goto fail;
90
91 WINPR_ASSERT(pos >= 4);
92 Stream_SetPosition(s, 2);
93 Stream_Write_UINT16(s, (UINT16)(pos - 4));
94 Stream_SetPosition(s, pos);
95
96 WINPR_ASSERT(context->priv);
97
98 status = WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
99 (UINT32)pos, &written);
100 Stream_SetPosition(s, 0);
101 }
102fail:
103 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
104}
105
111static UINT rdpsnd_server_recv_waveconfirm(RdpsndServerContext* context, wStream* s)
112{
113 UINT16 timestamp = 0;
114 BYTE confirmBlockNum = 0;
115 UINT error = CHANNEL_RC_OK;
116
117 WINPR_ASSERT(context);
118
119 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
120 return ERROR_INVALID_DATA;
121
122 Stream_Read_UINT16(s, timestamp);
123 Stream_Read_UINT8(s, confirmBlockNum);
124 Stream_Seek_UINT8(s);
125 IFCALLRET(context->ConfirmBlock, error, context, confirmBlockNum, timestamp);
126
127 if (error)
128 WLog_ERR(TAG, "context->ConfirmBlock failed with error %" PRIu32 "", error);
129
130 return error;
131}
132
138static UINT rdpsnd_server_recv_trainingconfirm(RdpsndServerContext* context, wStream* s)
139{
140 UINT16 timestamp = 0;
141 UINT16 packsize = 0;
142 UINT error = CHANNEL_RC_OK;
143
144 WINPR_ASSERT(context);
145
146 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
147 return ERROR_INVALID_DATA;
148
149 Stream_Read_UINT16(s, timestamp);
150 Stream_Read_UINT16(s, packsize);
151
152 IFCALLRET(context->TrainingConfirm, error, context, timestamp, packsize);
153 if (error)
154 WLog_ERR(TAG, "context->TrainingConfirm failed with error %" PRIu32 "", error);
155
156 return error;
157}
158
164static UINT rdpsnd_server_recv_quality_mode(RdpsndServerContext* context, wStream* s)
165{
166 WINPR_ASSERT(context);
167
168 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
169 {
170 WLog_ERR(TAG, "not enough data in stream!");
171 return ERROR_INVALID_DATA;
172 }
173
174 Stream_Read_UINT16(s, context->qualityMode); /* wQualityMode */
175 Stream_Seek_UINT16(s); /* Reserved */
176
177 WLog_DBG(TAG, "Client requested sound quality: 0x%04" PRIX16 "", context->qualityMode);
178
179 return CHANNEL_RC_OK;
180}
181
187static UINT rdpsnd_server_recv_formats(RdpsndServerContext* context, wStream* s)
188{
189 UINT error = CHANNEL_RC_OK;
190
191 WINPR_ASSERT(context);
192
193 if (!Stream_CheckAndLogRequiredLength(TAG, s, 20))
194 return ERROR_INVALID_DATA;
195
196 Stream_Read_UINT32(s, context->capsFlags); /* dwFlags */
197 Stream_Read_UINT32(s, context->initialVolume); /* dwVolume */
198 Stream_Read_UINT32(s, context->initialPitch); /* dwPitch */
199 Stream_Read_UINT16(s, context->udpPort); /* wDGramPort */
200 Stream_Read_UINT16(s, context->num_client_formats); /* wNumberOfFormats */
201 Stream_Read_UINT8(s, context->lastblock); /* cLastBlockConfirmed */
202 Stream_Read_UINT16(s, context->clientVersion); /* wVersion */
203 Stream_Seek_UINT8(s); /* bPad */
204
205 /* this check is only a guess as cbSize can influence the size of a format record */
206 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, context->num_client_formats, 18ull))
207 return ERROR_INVALID_DATA;
208
209 if (!context->num_client_formats)
210 {
211 WLog_ERR(TAG, "client doesn't support any format!");
212 return ERROR_INTERNAL_ERROR;
213 }
214
215 context->client_formats = audio_formats_new(context->num_client_formats);
216
217 if (!context->client_formats)
218 {
219 WLog_ERR(TAG, "calloc failed!");
220 return CHANNEL_RC_NO_MEMORY;
221 }
222
223 for (UINT16 i = 0; i < context->num_client_formats; i++)
224 {
225 AUDIO_FORMAT* format = &context->client_formats[i];
226
227 if (!Stream_CheckAndLogRequiredLength(TAG, s, 18))
228 {
229 WLog_ERR(TAG, "not enough data in stream!");
230 error = ERROR_INVALID_DATA;
231 goto out_free;
232 }
233
234 Stream_Read_UINT16(s, format->wFormatTag);
235 Stream_Read_UINT16(s, format->nChannels);
236 Stream_Read_UINT32(s, format->nSamplesPerSec);
237 Stream_Read_UINT32(s, format->nAvgBytesPerSec);
238 Stream_Read_UINT16(s, format->nBlockAlign);
239 Stream_Read_UINT16(s, format->wBitsPerSample);
240 Stream_Read_UINT16(s, format->cbSize);
241
242 if (format->cbSize > 0)
243 {
244 if (!Stream_SafeSeek(s, format->cbSize))
245 {
246 WLog_ERR(TAG, "Stream_SafeSeek failed!");
247 error = ERROR_INTERNAL_ERROR;
248 goto out_free;
249 }
250 }
251 }
252
253 if (!context->num_client_formats)
254 {
255 WLog_ERR(TAG, "client doesn't support any known format!");
256 goto out_free;
257 }
258
259 return CHANNEL_RC_OK;
260out_free:
261 free(context->client_formats);
262 return error;
263}
264
265static DWORD WINAPI rdpsnd_server_thread(LPVOID arg)
266{
267 DWORD nCount = 0;
268 DWORD status = 0;
269 HANDLE events[2] = { 0 };
270 RdpsndServerContext* context = (RdpsndServerContext*)arg;
271 UINT error = CHANNEL_RC_OK;
272
273 WINPR_ASSERT(context);
274 WINPR_ASSERT(context->priv);
275
276 events[nCount++] = context->priv->channelEvent;
277 events[nCount++] = context->priv->StopEvent;
278
279 WINPR_ASSERT(nCount <= ARRAYSIZE(events));
280
281 while (TRUE)
282 {
283 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
284
285 if (status == WAIT_FAILED)
286 {
287 error = GetLastError();
288 WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
289 break;
290 }
291
292 status = WaitForSingleObject(context->priv->StopEvent, 0);
293
294 if (status == WAIT_FAILED)
295 {
296 error = GetLastError();
297 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", error);
298 break;
299 }
300
301 if (status == WAIT_OBJECT_0)
302 break;
303
304 if ((error = rdpsnd_server_handle_messages(context)))
305 {
306 WLog_ERR(TAG, "rdpsnd_server_handle_messages failed with error %" PRIu32 "", error);
307 break;
308 }
309 }
310
311 if (error && context->rdpcontext)
312 setChannelError(context->rdpcontext, error, "rdpsnd_server_thread reported an error");
313
314 ExitThread(error);
315 return error;
316}
317
323static UINT rdpsnd_server_initialize(RdpsndServerContext* context, BOOL ownThread)
324{
325 WINPR_ASSERT(context);
326 WINPR_ASSERT(context->priv);
327
328 context->priv->ownThread = ownThread;
329 return context->Start(context);
330}
331
337static UINT rdpsnd_server_select_format(RdpsndServerContext* context, UINT16 client_format_index)
338{
339 size_t bs = 0;
340 size_t out_buffer_size = 0;
341 AUDIO_FORMAT* format = NULL;
342 UINT error = CHANNEL_RC_OK;
343
344 WINPR_ASSERT(context);
345 WINPR_ASSERT(context->priv);
346
347 if ((client_format_index >= context->num_client_formats) || (!context->src_format))
348 {
349 WLog_ERR(TAG, "index %" PRIu16 " is not correct.", client_format_index);
350 return ERROR_INVALID_DATA;
351 }
352
353 EnterCriticalSection(&context->priv->lock);
354 context->priv->src_bytes_per_sample = context->src_format->wBitsPerSample / 8;
355 context->priv->src_bytes_per_frame =
356 context->priv->src_bytes_per_sample * context->src_format->nChannels;
357 context->selected_client_format = client_format_index;
358 format = &context->client_formats[client_format_index];
359
360 if (format->nSamplesPerSec == 0)
361 {
362 WLog_ERR(TAG, "invalid Client Sound Format!!");
363 error = ERROR_INVALID_DATA;
364 goto out;
365 }
366
367 if (context->latency <= 0)
368 context->latency = 50;
369
370 context->priv->out_frames = context->src_format->nSamplesPerSec * context->latency / 1000;
371
372 if (context->priv->out_frames < 1)
373 context->priv->out_frames = 1;
374
375 switch (format->wFormatTag)
376 {
377 case WAVE_FORMAT_DVI_ADPCM:
378 bs = 4ULL * (format->nBlockAlign - 4ULL * format->nChannels);
379 context->priv->out_frames -= context->priv->out_frames % bs;
380
381 if (context->priv->out_frames < bs)
382 context->priv->out_frames = bs;
383
384 break;
385
386 case WAVE_FORMAT_ADPCM:
387 bs = (format->nBlockAlign - 7 * format->nChannels) * 2 / format->nChannels + 2;
388 context->priv->out_frames -= context->priv->out_frames % bs;
389
390 if (context->priv->out_frames < bs)
391 context->priv->out_frames = bs;
392
393 break;
394 default:
395 break;
396 }
397
398 context->priv->out_pending_frames = 0;
399 out_buffer_size = context->priv->out_frames * context->priv->src_bytes_per_frame;
400
401 if (context->priv->out_buffer_size < out_buffer_size)
402 {
403 BYTE* newBuffer = NULL;
404 newBuffer = (BYTE*)realloc(context->priv->out_buffer, out_buffer_size);
405
406 if (!newBuffer)
407 {
408 WLog_ERR(TAG, "realloc failed!");
409 error = CHANNEL_RC_NO_MEMORY;
410 goto out;
411 }
412
413 context->priv->out_buffer = newBuffer;
414 context->priv->out_buffer_size = out_buffer_size;
415 }
416
417 freerdp_dsp_context_reset(context->priv->dsp_context, format, 0u);
418out:
419 LeaveCriticalSection(&context->priv->lock);
420 return error;
421}
422
428static UINT rdpsnd_server_training(RdpsndServerContext* context, UINT16 timestamp, UINT16 packsize,
429 BYTE* data)
430{
431 ULONG written = 0;
432 BOOL status = 0;
433 wStream* s = rdpsnd_server_get_buffer(context);
434
435 if (!Stream_EnsureRemainingCapacity(s, 8))
436 return ERROR_INTERNAL_ERROR;
437
438 Stream_Write_UINT8(s, SNDC_TRAINING);
439 Stream_Write_UINT8(s, 0);
440 Stream_Seek_UINT16(s);
441 Stream_Write_UINT16(s, timestamp);
442 Stream_Write_UINT16(s, packsize);
443
444 if (packsize > 0)
445 {
446 if (!Stream_EnsureRemainingCapacity(s, packsize))
447 {
448 Stream_SetPosition(s, 0);
449 return ERROR_INTERNAL_ERROR;
450 }
451
452 Stream_Write(s, data, packsize);
453 }
454
455 const size_t end = Stream_GetPosition(s);
456 if ((end < 4) || (end > UINT16_MAX))
457 return ERROR_INTERNAL_ERROR;
458
459 Stream_SetPosition(s, 2);
460 Stream_Write_UINT16(s, (UINT16)(end - 4));
461
462 status = WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
463 (UINT32)end, &written);
464
465 Stream_SetPosition(s, 0);
466
467 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
468}
469
470static BOOL rdpsnd_server_align_wave_pdu(wStream* s, UINT32 alignment)
471{
472 size_t size = 0;
473 Stream_SealLength(s);
474 size = Stream_Length(s);
475
476 if ((size % alignment) != 0)
477 {
478 size_t offset = alignment - size % alignment;
479
480 if (!Stream_EnsureRemainingCapacity(s, offset))
481 return FALSE;
482
483 Stream_Zero(s, offset);
484 }
485
486 Stream_SealLength(s);
487 return TRUE;
488}
489
496static UINT rdpsnd_server_send_wave_pdu(RdpsndServerContext* context, UINT16 wTimestamp)
497{
498 AUDIO_FORMAT* format = NULL;
499 ULONG written = 0;
500 UINT error = CHANNEL_RC_OK;
501 wStream* s = rdpsnd_server_get_buffer(context);
502
503 if (context->selected_client_format > context->num_client_formats)
504 return ERROR_INTERNAL_ERROR;
505
506 WINPR_ASSERT(context->client_formats);
507
508 format = &context->client_formats[context->selected_client_format];
509 /* WaveInfo PDU */
510 Stream_SetPosition(s, 0);
511
512 if (!Stream_EnsureRemainingCapacity(s, 16))
513 return ERROR_OUTOFMEMORY;
514
515 Stream_Write_UINT8(s, SNDC_WAVE); /* msgType */
516 Stream_Write_UINT8(s, 0); /* bPad */
517 Stream_Write_UINT16(s, 0); /* BodySize */
518 Stream_Write_UINT16(s, wTimestamp); /* wTimeStamp */
519 Stream_Write_UINT16(s, context->selected_client_format); /* wFormatNo */
520 Stream_Write_UINT8(s, context->block_no); /* cBlockNo */
521 Stream_Seek(s, 3); /* bPad */
522 const size_t start = Stream_GetPosition(s);
523 const BYTE* src = context->priv->out_buffer;
524 const size_t length =
525 1ull * context->priv->out_pending_frames * context->priv->src_bytes_per_frame;
526
527 if (!freerdp_dsp_encode(context->priv->dsp_context, context->src_format, src, length, s))
528 return ERROR_INTERNAL_ERROR;
529
530 /* Set stream size */
531 if (!rdpsnd_server_align_wave_pdu(s, format->nBlockAlign))
532 return ERROR_INTERNAL_ERROR;
533
534 const size_t end = Stream_GetPosition(s);
535 const size_t pos = end - start + 8ULL;
536 if (pos > UINT16_MAX)
537 return ERROR_INTERNAL_ERROR;
538 Stream_SetPosition(s, 2);
539 Stream_Write_UINT16(s, (UINT16)pos);
540 Stream_SetPosition(s, end);
541
542 if (!WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
543 (UINT32)(start + 4), &written))
544 {
545 WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
546 error = ERROR_INTERNAL_ERROR;
547 }
548
549 if (error != CHANNEL_RC_OK)
550 {
551 WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
552 error = ERROR_INTERNAL_ERROR;
553 goto out;
554 }
555
556 Stream_SetPosition(s, start);
557 Stream_Write_UINT32(s, 0); /* bPad */
558 Stream_SetPosition(s, start);
559
560 WINPR_ASSERT((end - start) <= UINT32_MAX);
561 if (!WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_Pointer(s),
562 (UINT32)(end - start), &written))
563 {
564 WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
565 error = ERROR_INTERNAL_ERROR;
566 }
567
568 context->block_no = (context->block_no + 1) % 256;
569
570out:
571 Stream_SetPosition(s, 0);
572 context->priv->out_pending_frames = 0;
573 return error;
574}
575
582static UINT rdpsnd_server_send_wave2_pdu(RdpsndServerContext* context, UINT16 formatNo,
583 const BYTE* data, size_t size, BOOL encoded,
584 UINT16 timestamp, UINT32 audioTimeStamp)
585{
586 ULONG written = 0;
587 UINT error = CHANNEL_RC_OK;
588 BOOL status = 0;
589 wStream* s = rdpsnd_server_get_buffer(context);
590
591 if (!Stream_EnsureRemainingCapacity(s, 16))
592 {
593 error = ERROR_INTERNAL_ERROR;
594 goto out;
595 }
596
597 /* Wave2 PDU */
598 Stream_Write_UINT8(s, SNDC_WAVE2); /* msgType */
599 Stream_Write_UINT8(s, 0); /* bPad */
600 Stream_Write_UINT16(s, 0); /* BodySize */
601 Stream_Write_UINT16(s, timestamp); /* wTimeStamp */
602 Stream_Write_UINT16(s, formatNo); /* wFormatNo */
603 Stream_Write_UINT8(s, context->block_no); /* cBlockNo */
604 Stream_Write_UINT8(s, 0); /* bPad */
605 Stream_Write_UINT8(s, 0); /* bPad */
606 Stream_Write_UINT8(s, 0); /* bPad */
607 Stream_Write_UINT32(s, audioTimeStamp); /* dwAudioTimeStamp */
608
609 if (encoded)
610 {
611 if (!Stream_EnsureRemainingCapacity(s, size))
612 {
613 error = ERROR_INTERNAL_ERROR;
614 goto out;
615 }
616
617 Stream_Write(s, data, size);
618 }
619 else
620 {
621 AUDIO_FORMAT* format = NULL;
622
623 if (!freerdp_dsp_encode(context->priv->dsp_context, context->src_format, data, size, s))
624 {
625 error = ERROR_INTERNAL_ERROR;
626 goto out;
627 }
628
629 format = &context->client_formats[formatNo];
630 if (!rdpsnd_server_align_wave_pdu(s, format->nBlockAlign))
631 {
632 error = ERROR_INTERNAL_ERROR;
633 goto out;
634 }
635 }
636
637 {
638 const size_t end = Stream_GetPosition(s);
639 if (end > UINT16_MAX + 4)
640 {
641 error = ERROR_INTERNAL_ERROR;
642 goto out;
643 }
644
645 Stream_SetPosition(s, 2);
646 Stream_Write_UINT16(s, (UINT16)(end - 4));
647
648 status = WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
649 (UINT32)end, &written);
650
651 if (!status || (end != written))
652 {
653 WLog_ERR(TAG,
654 "WTSVirtualChannelWrite failed! [stream length=%" PRIuz " - written=%" PRIu32,
655 end, written);
656 error = ERROR_INTERNAL_ERROR;
657 }
658 }
659
660 context->block_no = (context->block_no + 1) % 256;
661
662out:
663 Stream_SetPosition(s, 0);
664 context->priv->out_pending_frames = 0;
665 return error;
666}
667
668/* Wrapper function to send WAVE or WAVE2 PDU depending on client connected */
669static UINT rdpsnd_server_send_audio_pdu(RdpsndServerContext* context, UINT16 wTimestamp)
670{
671 const BYTE* src = NULL;
672 size_t length = 0;
673
674 WINPR_ASSERT(context);
675 WINPR_ASSERT(context->priv);
676
677 if (context->selected_client_format >= context->num_client_formats)
678 return ERROR_INTERNAL_ERROR;
679
680 src = context->priv->out_buffer;
681 length = context->priv->out_pending_frames * context->priv->src_bytes_per_frame;
682
683 if (context->clientVersion >= CHANNEL_VERSION_WIN_8)
684 return rdpsnd_server_send_wave2_pdu(context, context->selected_client_format, src, length,
685 FALSE, wTimestamp, wTimestamp);
686 else
687 return rdpsnd_server_send_wave_pdu(context, wTimestamp);
688}
689
695static UINT rdpsnd_server_send_samples(RdpsndServerContext* context, const void* buf,
696 size_t nframes, UINT16 wTimestamp)
697{
698 UINT error = CHANNEL_RC_OK;
699
700 WINPR_ASSERT(context);
701 WINPR_ASSERT(context->priv);
702
703 EnterCriticalSection(&context->priv->lock);
704
705 if (context->selected_client_format >= context->num_client_formats)
706 {
707 /* It's possible while format negotiation has not been done */
708 WLog_WARN(TAG, "Drop samples because client format has not been negotiated.");
709 error = ERROR_NOT_READY;
710 goto out;
711 }
712
713 while (nframes > 0)
714 {
715 const size_t cframes =
716 MIN(nframes, context->priv->out_frames - context->priv->out_pending_frames);
717 size_t cframesize = cframes * context->priv->src_bytes_per_frame;
718 CopyMemory(context->priv->out_buffer +
719 (context->priv->out_pending_frames * context->priv->src_bytes_per_frame),
720 buf, cframesize);
721 buf = (const BYTE*)buf + cframesize;
722 nframes -= cframes;
723 context->priv->out_pending_frames += cframes;
724
725 if (context->priv->out_pending_frames >= context->priv->out_frames)
726 {
727 if ((error = rdpsnd_server_send_audio_pdu(context, wTimestamp)))
728 {
729 WLog_ERR(TAG, "rdpsnd_server_send_audio_pdu failed with error %" PRIu32 "", error);
730 break;
731 }
732 }
733 }
734
735out:
736 LeaveCriticalSection(&context->priv->lock);
737 return error;
738}
739
745static UINT rdpsnd_server_send_samples2(RdpsndServerContext* context, UINT16 formatNo,
746 const void* buf, size_t size, UINT16 timestamp,
747 UINT32 audioTimeStamp)
748{
749 UINT error = CHANNEL_RC_OK;
750
751 WINPR_ASSERT(context);
752 WINPR_ASSERT(context->priv);
753
754 if (context->clientVersion < CHANNEL_VERSION_WIN_8)
755 return ERROR_INTERNAL_ERROR;
756
757 EnterCriticalSection(&context->priv->lock);
758
759 error =
760 rdpsnd_server_send_wave2_pdu(context, formatNo, buf, size, TRUE, timestamp, audioTimeStamp);
761
762 LeaveCriticalSection(&context->priv->lock);
763
764 return error;
765}
766
772static UINT rdpsnd_server_set_volume(RdpsndServerContext* context, UINT16 left, UINT16 right)
773{
774 BOOL status = 0;
775 ULONG written = 0;
776 wStream* s = rdpsnd_server_get_buffer(context);
777
778 if (!Stream_EnsureRemainingCapacity(s, 8))
779 return ERROR_NOT_ENOUGH_MEMORY;
780
781 Stream_Write_UINT8(s, SNDC_SETVOLUME);
782 Stream_Write_UINT8(s, 0);
783 Stream_Write_UINT16(s, 4); /* Payload length */
784 Stream_Write_UINT16(s, left);
785 Stream_Write_UINT16(s, right);
786
787 const size_t len = Stream_GetPosition(s);
788 WINPR_ASSERT(len <= UINT32_MAX);
789 status = WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
790 (ULONG)len, &written);
791 Stream_SetPosition(s, 0);
792 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
793}
794
800static UINT rdpsnd_server_close(RdpsndServerContext* context)
801{
802 BOOL status = 0;
803 ULONG written = 0;
804 UINT error = CHANNEL_RC_OK;
805 wStream* s = rdpsnd_server_get_buffer(context);
806
807 EnterCriticalSection(&context->priv->lock);
808
809 if (context->priv->out_pending_frames > 0)
810 {
811 if (context->selected_client_format >= context->num_client_formats)
812 {
813 WLog_ERR(TAG, "Pending audio frame exists while no format selected.");
814 error = ERROR_INVALID_DATA;
815 }
816 else if ((error = rdpsnd_server_send_audio_pdu(context, 0)))
817 {
818 WLog_ERR(TAG, "rdpsnd_server_send_audio_pdu failed with error %" PRIu32 "", error);
819 }
820 }
821
822 LeaveCriticalSection(&context->priv->lock);
823
824 if (error)
825 return error;
826
827 context->selected_client_format = 0xFFFF;
828
829 if (!Stream_EnsureRemainingCapacity(s, 4))
830 return ERROR_OUTOFMEMORY;
831
832 Stream_Write_UINT8(s, SNDC_CLOSE);
833 Stream_Write_UINT8(s, 0);
834 Stream_Seek_UINT16(s);
835 const size_t pos = Stream_GetPosition(s);
836 WINPR_ASSERT(pos >= 4);
837 Stream_SetPosition(s, 2);
838 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, pos - 4));
839 Stream_SetPosition(s, pos);
840
841 const size_t len = Stream_GetPosition(s);
842 WINPR_ASSERT(len <= UINT32_MAX);
843 status = WTSVirtualChannelWrite(context->priv->ChannelHandle, Stream_BufferAs(s, char),
844 (UINT32)len, &written);
845 Stream_SetPosition(s, 0);
846 return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;
847}
848
854static UINT rdpsnd_server_start(RdpsndServerContext* context)
855{
856 void* buffer = NULL;
857 DWORD bytesReturned = 0;
858 RdpsndServerPrivate* priv = NULL;
859 UINT error = ERROR_INTERNAL_ERROR;
860 PULONG pSessionId = NULL;
861
862 WINPR_ASSERT(context);
863 WINPR_ASSERT(context->priv);
864
865 priv = context->priv;
866 priv->SessionId = WTS_CURRENT_SESSION;
867
868 if (context->use_dynamic_virtual_channel)
869 {
870 UINT32 channelId = 0;
871 BOOL status = TRUE;
872
873 if (WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION, WTSSessionId,
874 (LPSTR*)&pSessionId, &bytesReturned))
875 {
876 priv->SessionId = (DWORD)*pSessionId;
877 WTSFreeMemory(pSessionId);
878 priv->ChannelHandle = WTSVirtualChannelOpenEx(priv->SessionId, RDPSND_DVC_CHANNEL_NAME,
879 WTS_CHANNEL_OPTION_DYNAMIC);
880 if (!priv->ChannelHandle)
881 {
882 WLog_ERR(TAG, "Open audio dynamic virtual channel (%s) failed!",
883 RDPSND_DVC_CHANNEL_NAME);
884 return ERROR_INTERNAL_ERROR;
885 }
886
887 channelId = WTSChannelGetIdByHandle(priv->ChannelHandle);
888
889 IFCALLRET(context->ChannelIdAssigned, status, context, channelId);
890 if (!status)
891 {
892 WLog_ERR(TAG, "context->ChannelIdAssigned failed!");
893 goto out_close;
894 }
895 }
896 else
897 {
898 WLog_ERR(TAG, "WTSQuerySessionInformationA failed!");
899 return ERROR_INTERNAL_ERROR;
900 }
901 }
902 else
903 {
904 priv->ChannelHandle =
905 WTSVirtualChannelOpen(context->vcm, WTS_CURRENT_SESSION, RDPSND_CHANNEL_NAME);
906 if (!priv->ChannelHandle)
907 {
908 WLog_ERR(TAG, "Open audio static virtual channel (rdpsnd) failed!");
909 return ERROR_INTERNAL_ERROR;
910 }
911 }
912
913 if (!WTSVirtualChannelQuery(priv->ChannelHandle, WTSVirtualEventHandle, &buffer,
914 &bytesReturned) ||
915 (bytesReturned != sizeof(HANDLE)))
916 {
917 WLog_ERR(TAG,
918 "error during WTSVirtualChannelQuery(WTSVirtualEventHandle) or invalid returned "
919 "size(%" PRIu32 ")",
920 bytesReturned);
921
922 if (buffer)
923 WTSFreeMemory(buffer);
924
925 goto out_close;
926 }
927
928 priv->channelEvent = *(HANDLE*)buffer;
929 WTSFreeMemory(buffer);
930 priv->rdpsnd_pdu = Stream_New(NULL, 4096);
931
932 if (!priv->rdpsnd_pdu)
933 {
934 WLog_ERR(TAG, "Stream_New failed!");
935 error = CHANNEL_RC_NO_MEMORY;
936 goto out_close;
937 }
938
939 if (!InitializeCriticalSectionEx(&context->priv->lock, 0, 0))
940 {
941 WLog_ERR(TAG, "InitializeCriticalSectionEx failed!");
942 goto out_pdu;
943 }
944
945 if ((error = rdpsnd_server_send_formats(context)))
946 {
947 WLog_ERR(TAG, "rdpsnd_server_send_formats failed with error %" PRIu32 "", error);
948 goto out_lock;
949 }
950
951 if (priv->ownThread)
952 {
953 context->priv->StopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
954
955 if (!context->priv->StopEvent)
956 {
957 WLog_ERR(TAG, "CreateEvent failed!");
958 goto out_lock;
959 }
960
961 context->priv->Thread =
962 CreateThread(NULL, 0, rdpsnd_server_thread, (void*)context, 0, NULL);
963
964 if (!context->priv->Thread)
965 {
966 WLog_ERR(TAG, "CreateThread failed!");
967 goto out_stopEvent;
968 }
969 }
970
971 return CHANNEL_RC_OK;
972out_stopEvent:
973 (void)CloseHandle(context->priv->StopEvent);
974 context->priv->StopEvent = NULL;
975out_lock:
976 DeleteCriticalSection(&context->priv->lock);
977out_pdu:
978 Stream_Free(context->priv->rdpsnd_pdu, TRUE);
979 context->priv->rdpsnd_pdu = NULL;
980out_close:
981 (void)WTSVirtualChannelClose(context->priv->ChannelHandle);
982 context->priv->ChannelHandle = NULL;
983 return error;
984}
985
991static UINT rdpsnd_server_stop(RdpsndServerContext* context)
992{
993 UINT error = CHANNEL_RC_OK;
994
995 WINPR_ASSERT(context);
996 WINPR_ASSERT(context->priv);
997
998 if (!context->priv->StopEvent)
999 return error;
1000
1001 if (context->priv->ownThread)
1002 {
1003 if (context->priv->StopEvent)
1004 {
1005 (void)SetEvent(context->priv->StopEvent);
1006
1007 if (WaitForSingleObject(context->priv->Thread, INFINITE) == WAIT_FAILED)
1008 {
1009 error = GetLastError();
1010 WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", error);
1011 return error;
1012 }
1013
1014 (void)CloseHandle(context->priv->Thread);
1015 (void)CloseHandle(context->priv->StopEvent);
1016 context->priv->Thread = NULL;
1017 context->priv->StopEvent = NULL;
1018 }
1019 }
1020
1021 DeleteCriticalSection(&context->priv->lock);
1022
1023 if (context->priv->rdpsnd_pdu)
1024 {
1025 Stream_Free(context->priv->rdpsnd_pdu, TRUE);
1026 context->priv->rdpsnd_pdu = NULL;
1027 }
1028
1029 if (context->priv->ChannelHandle)
1030 {
1031 (void)WTSVirtualChannelClose(context->priv->ChannelHandle);
1032 context->priv->ChannelHandle = NULL;
1033 }
1034
1035 return error;
1036}
1037
1038RdpsndServerContext* rdpsnd_server_context_new(HANDLE vcm)
1039{
1040 RdpsndServerPrivate* priv = NULL;
1041 RdpsndServerContext* context = (RdpsndServerContext*)calloc(1, sizeof(RdpsndServerContext));
1042
1043 if (!context)
1044 goto fail;
1045
1046 context->vcm = vcm;
1047 context->Start = rdpsnd_server_start;
1048 context->Stop = rdpsnd_server_stop;
1049 context->selected_client_format = 0xFFFF;
1050 context->Initialize = rdpsnd_server_initialize;
1051 context->SendFormats = rdpsnd_server_send_formats;
1052 context->SelectFormat = rdpsnd_server_select_format;
1053 context->Training = rdpsnd_server_training;
1054 context->SendSamples = rdpsnd_server_send_samples;
1055 context->SendSamples2 = rdpsnd_server_send_samples2;
1056 context->SetVolume = rdpsnd_server_set_volume;
1057 context->Close = rdpsnd_server_close;
1058 context->priv = priv = (RdpsndServerPrivate*)calloc(1, sizeof(RdpsndServerPrivate));
1059
1060 if (!priv)
1061 {
1062 WLog_ERR(TAG, "calloc failed!");
1063 goto fail;
1064 }
1065
1066 priv->dsp_context = freerdp_dsp_context_new(TRUE);
1067
1068 if (!priv->dsp_context)
1069 {
1070 WLog_ERR(TAG, "freerdp_dsp_context_new failed!");
1071 goto fail;
1072 }
1073
1074 priv->input_stream = Stream_New(NULL, 4);
1075
1076 if (!priv->input_stream)
1077 {
1078 WLog_ERR(TAG, "Stream_New failed!");
1079 goto fail;
1080 }
1081
1082 priv->expectedBytes = 4;
1083 priv->waitingHeader = TRUE;
1084 priv->ownThread = TRUE;
1085 return context;
1086fail:
1087 WINPR_PRAGMA_DIAG_PUSH
1088 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1089 rdpsnd_server_context_free(context);
1090 WINPR_PRAGMA_DIAG_POP
1091 return NULL;
1092}
1093
1094void rdpsnd_server_context_reset(RdpsndServerContext* context)
1095{
1096 WINPR_ASSERT(context);
1097 WINPR_ASSERT(context->priv);
1098
1099 context->priv->expectedBytes = 4;
1100 context->priv->waitingHeader = TRUE;
1101 Stream_SetPosition(context->priv->input_stream, 0);
1102}
1103
1104void rdpsnd_server_context_free(RdpsndServerContext* context)
1105{
1106 if (!context)
1107 return;
1108
1109 if (context->priv)
1110 {
1111 rdpsnd_server_stop(context);
1112
1113 free(context->priv->out_buffer);
1114
1115 if (context->priv->dsp_context)
1116 freerdp_dsp_context_free(context->priv->dsp_context);
1117
1118 if (context->priv->input_stream)
1119 Stream_Free(context->priv->input_stream, TRUE);
1120 }
1121
1122 free(context->server_formats);
1123 free(context->client_formats);
1124 free(context->priv);
1125 free(context);
1126}
1127
1128HANDLE rdpsnd_server_get_event_handle(RdpsndServerContext* context)
1129{
1130 WINPR_ASSERT(context);
1131 WINPR_ASSERT(context->priv);
1132
1133 return context->priv->channelEvent;
1134}
1135
1136/*
1137 * Handle rpdsnd messages - server side
1138 *
1139 * @param Server side context
1140 *
1141 * @return 0 on success
1142 * ERROR_NO_DATA if no data could be read this time
1143 * otherwise error
1144 */
1150UINT rdpsnd_server_handle_messages(RdpsndServerContext* context)
1151{
1152 DWORD bytesReturned = 0;
1153 UINT ret = CHANNEL_RC_OK;
1154 RdpsndServerPrivate* priv = NULL;
1155 wStream* s = NULL;
1156
1157 WINPR_ASSERT(context);
1158 WINPR_ASSERT(context->priv);
1159
1160 priv = context->priv;
1161 s = priv->input_stream;
1162
1163 if (!WTSVirtualChannelRead(priv->ChannelHandle, 0, Stream_Pointer(s), priv->expectedBytes,
1164 &bytesReturned))
1165 {
1166 if (GetLastError() == ERROR_NO_DATA)
1167 return ERROR_NO_DATA;
1168
1169 WLog_ERR(TAG, "channel connection closed");
1170 return ERROR_INTERNAL_ERROR;
1171 }
1172
1173 priv->expectedBytes -= bytesReturned;
1174 Stream_Seek(s, bytesReturned);
1175
1176 if (priv->expectedBytes)
1177 return CHANNEL_RC_OK;
1178
1179 Stream_SealLength(s);
1180 Stream_SetPosition(s, 0);
1181
1182 if (priv->waitingHeader)
1183 {
1184 /* header case */
1185 Stream_Read_UINT8(s, priv->msgType);
1186 Stream_Seek_UINT8(s); /* bPad */
1187 Stream_Read_UINT16(s, priv->expectedBytes);
1188 priv->waitingHeader = FALSE;
1189 Stream_SetPosition(s, 0);
1190
1191 if (priv->expectedBytes)
1192 {
1193 if (!Stream_EnsureCapacity(s, priv->expectedBytes))
1194 {
1195 WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
1196 return CHANNEL_RC_NO_MEMORY;
1197 }
1198
1199 return CHANNEL_RC_OK;
1200 }
1201 }
1202
1203 /* when here we have the header + the body */
1204#ifdef WITH_DEBUG_SND
1205 WLog_DBG(TAG, "message type %" PRIu8 "", priv->msgType);
1206#endif
1207 priv->expectedBytes = 4;
1208 priv->waitingHeader = TRUE;
1209
1210 switch (priv->msgType)
1211 {
1212 case SNDC_WAVECONFIRM:
1213 ret = rdpsnd_server_recv_waveconfirm(context, s);
1214 break;
1215
1216 case SNDC_TRAINING:
1217 ret = rdpsnd_server_recv_trainingconfirm(context, s);
1218 break;
1219
1220 case SNDC_FORMATS:
1221 ret = rdpsnd_server_recv_formats(context, s);
1222
1223 if ((ret == CHANNEL_RC_OK) && (context->clientVersion < CHANNEL_VERSION_WIN_7))
1224 IFCALL(context->Activated, context);
1225
1226 break;
1227
1228 case SNDC_QUALITYMODE:
1229 ret = rdpsnd_server_recv_quality_mode(context, s);
1230
1231 if ((ret == CHANNEL_RC_OK) && (context->clientVersion >= CHANNEL_VERSION_WIN_7))
1232 IFCALL(context->Activated, context);
1233
1234 break;
1235
1236 default:
1237 WLog_ERR(TAG, "UNKNOWN MESSAGE TYPE!! (0x%02" PRIX8 ")", priv->msgType);
1238 ret = ERROR_INVALID_DATA;
1239 break;
1240 }
1241
1242 Stream_SetPosition(s, 0);
1243 return ret;
1244}
AUDIO_FORMAT
Definition audio.h:34