FreeRDP
Loading...
Searching...
No Matches
audin_pulse.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/cmdline.h>
30#include <winpr/wlog.h>
31#include <winpr/cast.h>
32
33#include <pulse/pulseaudio.h>
34
35#include <freerdp/types.h>
36#include <freerdp/addin.h>
37#include <freerdp/freerdp.h>
38#include <freerdp/codec/audio.h>
39#include <freerdp/client/audin.h>
40#include <freerdp/utils/helpers.h>
41
42#include "audin_main.h"
43
44typedef struct
45{
46 IAudinDevice iface;
47
48 char* device_name;
49 char* client_name;
50 char* stream_name;
51 UINT32 frames_per_packet;
52 pa_threaded_mainloop* mainloop;
53 pa_context* context;
54 pa_sample_spec sample_spec;
55 pa_stream* stream;
56 AUDIO_FORMAT format;
57
58 size_t bytes_per_frame;
59 size_t buffer_frames;
60
61 AudinReceive receive;
62 void* user_data;
63
64 rdpContext* rdpcontext;
65 wLog* log;
66} AudinPulseDevice;
67
68static const char* pulse_context_state_string(pa_context_state_t state)
69{
70 switch (state)
71 {
72 case PA_CONTEXT_UNCONNECTED:
73 return "PA_CONTEXT_UNCONNECTED";
74 case PA_CONTEXT_CONNECTING:
75 return "PA_CONTEXT_CONNECTING";
76 case PA_CONTEXT_AUTHORIZING:
77 return "PA_CONTEXT_AUTHORIZING";
78 case PA_CONTEXT_SETTING_NAME:
79 return "PA_CONTEXT_SETTING_NAME";
80 case PA_CONTEXT_READY:
81 return "PA_CONTEXT_READY";
82 case PA_CONTEXT_FAILED:
83 return "PA_CONTEXT_FAILED";
84 case PA_CONTEXT_TERMINATED:
85 return "PA_CONTEXT_TERMINATED";
86 default:
87 return "UNKNOWN";
88 }
89}
90
91static const char* pulse_stream_state_string(pa_stream_state_t state)
92{
93 switch (state)
94 {
95 case PA_STREAM_UNCONNECTED:
96 return "PA_STREAM_UNCONNECTED";
97 case PA_STREAM_CREATING:
98 return "PA_STREAM_CREATING";
99 case PA_STREAM_READY:
100 return "PA_STREAM_READY";
101 case PA_STREAM_FAILED:
102 return "PA_STREAM_FAILED";
103 case PA_STREAM_TERMINATED:
104 return "PA_STREAM_TERMINATED";
105 default:
106 return "UNKNOWN";
107 }
108}
109
110static void audin_pulse_context_state_callback(pa_context* context, void* userdata)
111{
112 AudinPulseDevice* pulse = (AudinPulseDevice*)userdata;
113 pa_context_state_t state = pa_context_get_state(context);
114
115 WLog_Print(pulse->log, WLOG_DEBUG, "context state %s", pulse_context_state_string(state));
116 switch (state)
117 {
118 case PA_CONTEXT_READY:
119 case PA_CONTEXT_FAILED:
120 case PA_CONTEXT_TERMINATED:
121 pa_threaded_mainloop_signal(pulse->mainloop, 0);
122 break;
123
124 default:
125 break;
126 }
127}
128
134static UINT audin_pulse_connect(IAudinDevice* device)
135{
136 pa_context_state_t state = PA_CONTEXT_FAILED;
137 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
138
139 if (!pulse->context)
140 return ERROR_INVALID_PARAMETER;
141
142 if (pa_context_connect(pulse->context, nullptr, PA_CONTEXT_NOFLAGS, nullptr))
143 {
144 WLog_Print(pulse->log, WLOG_ERROR, "pa_context_connect failed (%d)",
145 pa_context_errno(pulse->context));
146 return ERROR_INTERNAL_ERROR;
147 }
148
149 pa_threaded_mainloop_lock(pulse->mainloop);
150
151 if (pa_threaded_mainloop_start(pulse->mainloop) < 0)
152 {
153 pa_threaded_mainloop_unlock(pulse->mainloop);
154 WLog_Print(pulse->log, WLOG_ERROR, "pa_threaded_mainloop_start failed (%d)",
155 pa_context_errno(pulse->context));
156 return ERROR_INTERNAL_ERROR;
157 }
158
159 for (;;)
160 {
161 state = pa_context_get_state(pulse->context);
162
163 if (state == PA_CONTEXT_READY)
164 break;
165
166 if (!PA_CONTEXT_IS_GOOD(state))
167 {
168 WLog_Print(pulse->log, WLOG_ERROR, "bad context state (%s: %d)",
169 pulse_context_state_string(state), pa_context_errno(pulse->context));
170 pa_context_disconnect(pulse->context);
171 return ERROR_INVALID_STATE;
172 }
173
174 pa_threaded_mainloop_wait(pulse->mainloop);
175 }
176
177 pa_threaded_mainloop_unlock(pulse->mainloop);
178 WLog_Print(pulse->log, WLOG_DEBUG, "connected");
179 return CHANNEL_RC_OK;
180}
181
187static UINT audin_pulse_free(IAudinDevice* device)
188{
189 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
190
191 if (!pulse)
192 return ERROR_INVALID_PARAMETER;
193
194 if (pulse->mainloop)
195 {
196 pa_threaded_mainloop_stop(pulse->mainloop);
197 }
198
199 if (pulse->context)
200 {
201 pa_context_disconnect(pulse->context);
202 pa_context_unref(pulse->context);
203 pulse->context = nullptr;
204 }
205
206 if (pulse->mainloop)
207 {
208 pa_threaded_mainloop_free(pulse->mainloop);
209 pulse->mainloop = nullptr;
210 }
211
212 free(pulse->device_name);
213 free(pulse->client_name);
214 free(pulse->stream_name);
215 free(pulse);
216 return CHANNEL_RC_OK;
217}
218
219static BOOL audin_pulse_format_supported(IAudinDevice* device, const AUDIO_FORMAT* format)
220{
221 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
222
223 if (!pulse || !format)
224 return FALSE;
225
226 if (!pulse->context)
227 return 0;
228
229 switch (format->wFormatTag)
230 {
231 case WAVE_FORMAT_PCM:
232 if (format->cbSize == 0 && (format->nSamplesPerSec <= PA_RATE_MAX) &&
233 (format->wBitsPerSample == 8 || format->wBitsPerSample == 16) &&
234 (format->nChannels >= 1 && format->nChannels <= PA_CHANNELS_MAX))
235 {
236 return TRUE;
237 }
238
239 break;
240
241 default:
242 return FALSE;
243 }
244
245 return FALSE;
246}
247
253static UINT audin_pulse_set_format(IAudinDevice* device, const AUDIO_FORMAT* format,
254 UINT32 FramesPerPacket)
255{
256 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
257
258 if (!pulse || !format)
259 return ERROR_INVALID_PARAMETER;
260
261 if (!pulse->context)
262 return ERROR_INVALID_PARAMETER;
263
264 if (FramesPerPacket > 0)
265 pulse->frames_per_packet = FramesPerPacket;
266
267 pa_sample_format_t sformat = PA_SAMPLE_INVALID;
268 switch (format->wFormatTag)
269 {
270 case WAVE_FORMAT_PCM: /* PCM */
271 switch (format->wBitsPerSample)
272 {
273 case 8:
274 sformat = PA_SAMPLE_U8;
275 break;
276
277 case 16:
278 sformat = PA_SAMPLE_S16LE;
279 break;
280
281 default:
282 return ERROR_INTERNAL_ERROR;
283 }
284
285 break;
286
287 default:
288 return ERROR_INTERNAL_ERROR;
289 }
290
291 const pa_sample_spec sample_spec = {
292 .format = sformat,
293 .rate = format->nSamplesPerSec,
294 .channels = WINPR_ASSERTING_INT_CAST(uint8_t, format->nChannels),
295 };
296
297 pulse->sample_spec = sample_spec;
298 pulse->format = *format;
299 return CHANNEL_RC_OK;
300}
301
302static void audin_pulse_stream_state_callback(pa_stream* stream, void* userdata)
303{
304 AudinPulseDevice* pulse = (AudinPulseDevice*)userdata;
305 WINPR_ASSERT(pulse);
306
307 pa_stream_state_t state = pa_stream_get_state(stream);
308
309 WLog_Print(pulse->log, WLOG_DEBUG, "stream state %s", pulse_stream_state_string(state));
310 switch (state)
311 {
312 case PA_STREAM_READY:
313 case PA_STREAM_FAILED:
314 case PA_STREAM_TERMINATED:
315 pa_threaded_mainloop_signal(pulse->mainloop, 0);
316 break;
317
318 case PA_STREAM_UNCONNECTED:
319 case PA_STREAM_CREATING:
320 default:
321 break;
322 }
323}
324
325static void audin_pulse_stream_request_callback(pa_stream* stream, size_t length, void* userdata)
326{
327 const void* data = nullptr;
328 AudinPulseDevice* pulse = (AudinPulseDevice*)userdata;
329 UINT error = CHANNEL_RC_OK;
330
331 if (pa_stream_peek(stream, &data, &length) < 0)
332 {
333 WLog_Print(pulse->log, WLOG_WARN, "pa_stream_peek failed (%d)",
334 pa_context_errno(pulse->context));
335 return;
336 }
337
338 /* length == 0: buffer empty, no fragment to drop.
339 * data == nullptr with length > 0: a hole in the record stream (e.g. the
340 * capture device vanished); it carries no samples, only drop it. */
341 if (length == 0)
342 return;
343
344 if (data)
345 error = IFCALLRESULT(CHANNEL_RC_OK, pulse->receive, &pulse->format, data, length,
346 pulse->user_data);
347 pa_stream_drop(stream);
348
349 if (error && pulse->rdpcontext)
350 setChannelError(pulse->rdpcontext, error, "audin_pulse_thread_func reported an error");
351}
352
358static UINT audin_pulse_close(IAudinDevice* device)
359{
360 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
361
362 if (!pulse)
363 return ERROR_INVALID_PARAMETER;
364
365 if (pulse->stream)
366 {
367 pa_threaded_mainloop_lock(pulse->mainloop);
368 pa_stream_disconnect(pulse->stream);
369 pa_stream_unref(pulse->stream);
370 pulse->stream = nullptr;
371 pa_threaded_mainloop_unlock(pulse->mainloop);
372 }
373
374 pulse->receive = nullptr;
375 pulse->user_data = nullptr;
376 return CHANNEL_RC_OK;
377}
378
384static UINT audin_pulse_open(IAudinDevice* device, AudinReceive receive, void* user_data)
385{
386 pa_stream_state_t state = PA_STREAM_FAILED;
387 pa_buffer_attr buffer_attr = WINPR_C_ARRAY_INIT;
388 AudinPulseDevice* pulse = (AudinPulseDevice*)device;
389
390 if (!pulse || !receive || !user_data)
391 return ERROR_INVALID_PARAMETER;
392
393 if (!pulse->context)
394 return ERROR_INVALID_PARAMETER;
395
396 if (!pulse->sample_spec.rate || pulse->stream)
397 return ERROR_INVALID_PARAMETER;
398
399 pulse->receive = receive;
400 pulse->user_data = user_data;
401 pa_threaded_mainloop_lock(pulse->mainloop);
402 pulse->stream = pa_stream_new(pulse->context, pulse->stream_name, &pulse->sample_spec, nullptr);
403
404 if (!pulse->stream)
405 {
406 pa_threaded_mainloop_unlock(pulse->mainloop);
407 WLog_Print(pulse->log, WLOG_DEBUG, "pa_stream_new failed (%d)",
408 pa_context_errno(pulse->context));
409 const int rc = pa_context_errno(pulse->context);
410 return (UINT)rc;
411 }
412
413 pulse->bytes_per_frame = pa_frame_size(&pulse->sample_spec);
414 pa_stream_set_state_callback(pulse->stream, audin_pulse_stream_state_callback, pulse);
415 pa_stream_set_read_callback(pulse->stream, audin_pulse_stream_request_callback, pulse);
416 buffer_attr.maxlength = UINT32_MAX;
417 buffer_attr.tlength = UINT32_MAX;
418 buffer_attr.prebuf = UINT32_MAX;
419 buffer_attr.minreq = UINT32_MAX;
420 /* 500ms latency */
421 if ((pulse->bytes_per_frame == 0) || (pulse->frames_per_packet == 0) ||
422 (pulse->bytes_per_frame > UINT32_MAX / pulse->frames_per_packet))
423 {
424 pa_threaded_mainloop_unlock(pulse->mainloop);
425 return CHANNEL_RC_BAD_INIT_HANDLE;
426 }
427
428 const size_t frag = pulse->bytes_per_frame * pulse->frames_per_packet;
429 WINPR_ASSERT(frag <= UINT32_MAX);
430 buffer_attr.fragsize = (uint32_t)frag;
431
432 if (buffer_attr.fragsize % pulse->format.nBlockAlign)
433 buffer_attr.fragsize +=
434 pulse->format.nBlockAlign - buffer_attr.fragsize % pulse->format.nBlockAlign;
435
436 if (pa_stream_connect_record(pulse->stream, pulse->device_name, &buffer_attr,
437 PA_STREAM_ADJUST_LATENCY) < 0)
438 {
439 pa_threaded_mainloop_unlock(pulse->mainloop);
440 WLog_Print(pulse->log, WLOG_ERROR, "pa_stream_connect_playback failed (%d)",
441 pa_context_errno(pulse->context));
442 const int rc = pa_context_errno(pulse->context);
443 return (UINT)rc;
444 }
445
446 while (pulse->stream)
447 {
448 state = pa_stream_get_state(pulse->stream);
449
450 if (state == PA_STREAM_READY)
451 break;
452
453 if (!PA_STREAM_IS_GOOD(state))
454 {
455 audin_pulse_close(device);
456 WLog_Print(pulse->log, WLOG_ERROR, "bad stream state (%s: %d)",
457 pulse_stream_state_string(state), pa_context_errno(pulse->context));
458 pa_threaded_mainloop_unlock(pulse->mainloop);
459 const int rc = pa_context_errno(pulse->context);
460 return (UINT)rc;
461 }
462
463 pa_threaded_mainloop_wait(pulse->mainloop);
464 }
465
466 pa_threaded_mainloop_unlock(pulse->mainloop);
467 pulse->buffer_frames = 0;
468 WLog_Print(pulse->log, WLOG_DEBUG, "connected");
469 return CHANNEL_RC_OK;
470}
471
477static UINT audin_pulse_parse_addin_args(AudinPulseDevice* pulse, const ADDIN_ARGV* args)
478{
479 COMMAND_LINE_ARGUMENT_A audin_pulse_args[] = {
480 { "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", nullptr, nullptr, -1, nullptr,
481 "audio device name" },
482 { "client_name", COMMAND_LINE_VALUE_REQUIRED, "<client_name>", nullptr, nullptr, -1,
483 nullptr, "name of pulse client" },
484 { "stream_name", COMMAND_LINE_VALUE_REQUIRED, "<stream_name>", nullptr, nullptr, -1,
485 nullptr, "name of pulse stream" },
486 { nullptr, 0, nullptr, nullptr, nullptr, -1, nullptr, nullptr }
487 };
488
489 const DWORD flags =
490 COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON | COMMAND_LINE_IGN_UNKNOWN_KEYWORD;
491 const int status = CommandLineParseArgumentsA(args->argc, args->argv, audin_pulse_args, flags,
492 pulse, nullptr, nullptr);
493
494 if (status < 0)
495 return ERROR_INVALID_PARAMETER;
496
497 const COMMAND_LINE_ARGUMENT_A* arg = audin_pulse_args;
498
499 const char* client_name = nullptr;
500 const char* stream_name = nullptr;
501 do
502 {
503 if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
504 continue;
505
506 CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "dev")
507 {
508 pulse->device_name = _strdup(arg->Value);
509
510 if (!pulse->device_name)
511 {
512 WLog_Print(pulse->log, WLOG_ERROR, "_strdup failed!");
513 return CHANNEL_RC_NO_MEMORY;
514 }
515 }
516 CommandLineSwitchEnd(arg)
517 } while ((arg = CommandLineFindNextArgumentA(arg)) != nullptr);
518
519 if (!client_name)
520 client_name = freerdp_getApplicationDetailsString();
521 if (!stream_name)
522 stream_name = freerdp_getApplicationDetailsString();
523
524 pulse->client_name = _strdup(client_name);
525 pulse->stream_name = _strdup(stream_name);
526 if (!pulse->client_name || !pulse->stream_name)
527 return ERROR_OUTOFMEMORY;
528
529 return CHANNEL_RC_OK;
530}
531
537FREERDP_ENTRY_POINT(UINT VCAPITYPE pulse_freerdp_audin_client_subsystem_entry(
539{
540 const ADDIN_ARGV* args = nullptr;
541 AudinPulseDevice* pulse = nullptr;
542 UINT error = 0;
543 pulse = (AudinPulseDevice*)calloc(1, sizeof(AudinPulseDevice));
544
545 if (!pulse)
546 {
547 WLog_ERR(TAG, "calloc failed!");
548 return CHANNEL_RC_NO_MEMORY;
549 }
550
551 pulse->log = WLog_Get(TAG);
552 pulse->iface.Open = audin_pulse_open;
553 pulse->iface.FormatSupported = audin_pulse_format_supported;
554 pulse->iface.SetFormat = audin_pulse_set_format;
555 pulse->iface.Close = audin_pulse_close;
556 pulse->iface.Free = audin_pulse_free;
557 pulse->rdpcontext = pEntryPoints->rdpcontext;
558 args = pEntryPoints->args;
559
560 if ((error = audin_pulse_parse_addin_args(pulse, args)))
561 {
562 WLog_Print(pulse->log, WLOG_ERROR,
563 "audin_pulse_parse_addin_args failed with error %" PRIu32 "!", error);
564 goto error_out;
565 }
566
567 pulse->mainloop = pa_threaded_mainloop_new();
568
569 if (!pulse->mainloop)
570 {
571 WLog_Print(pulse->log, WLOG_ERROR, "pa_threaded_mainloop_new failed");
572 error = CHANNEL_RC_NO_MEMORY;
573 goto error_out;
574 }
575
576 pulse->context =
577 pa_context_new(pa_threaded_mainloop_get_api(pulse->mainloop), pulse->client_name);
578
579 if (!pulse->context)
580 {
581 WLog_Print(pulse->log, WLOG_ERROR, "pa_context_new failed");
582 error = CHANNEL_RC_NO_MEMORY;
583 goto error_out;
584 }
585
586 pa_context_set_state_callback(pulse->context, audin_pulse_context_state_callback, pulse);
587
588 if ((error = audin_pulse_connect(&pulse->iface)))
589 {
590 WLog_Print(pulse->log, WLOG_ERROR, "audin_pulse_connect failed");
591 goto error_out;
592 }
593
594 if ((error = pEntryPoints->pRegisterAudinDevice(pEntryPoints->plugin, &pulse->iface)))
595 {
596 WLog_Print(pulse->log, WLOG_ERROR, "RegisterAudinDevice failed with error %" PRIu32 "!",
597 error);
598 goto error_out;
599 }
600
601 return CHANNEL_RC_OK;
602error_out:
603 audin_pulse_free(&pulse->iface);
604 return error;
605}