← Back to branch summary

~ubuntu-branches/ubuntu/vivid/freerdp/vivid

« back to all changes in this revision

Viewing changes to channels/drdynvc/audin/pulse/audin_pulse.c

  • Committer: Package Import Robot
  • Author(s): Iain Lane
  • Date: 2014-11-11 12:20:50 UTC
  • mfrom: (1.2.5)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20141111122050-7z628f4ab38qxad5
Tags: upstream-1.1.0~git20140921.1.440916e+dfsg1
Import upstream version 1.1.0~git20140921.1.440916e+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
channels/drdynvc/audin/pulse/audin_pulse.c
1
 
/**
2
 
 * FreeRDP: A Remote Desktop Protocol client.
3
 
 * Audio Input Redirection Virtual Channel - PulseAudio implementation
4
 
 *
5
 
 * Copyright 2010-2011 Vic Lee
6
 
 *
7
 
 * Licensed under the Apache License, Version 2.0 (the "License");
8
 
 * you may not use this file except in compliance with the License.
9
 
 * You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
#include <stdio.h>
21
 
#include <stdlib.h>
22
 
#include <string.h>
23
 
#include <pulse/pulseaudio.h>
24
 
#include <freerdp/types.h>
25
 
#include <freerdp/utils/memory.h>
26
 
#include <freerdp/utils/dsp.h>
27
 
 
28
 
#include "audin_main.h"
29
 
 
30
 
typedef struct _AudinPulseDevice
31
 
{
32
 
        IAudinDevice iface;
33
 
 
34
 
        char device_name[32];
35
 
        uint32 frames_per_packet;
36
 
        pa_threaded_mainloop* mainloop;
37
 
        pa_context* context;
38
 
        pa_sample_spec sample_spec;
39
 
        pa_stream* stream;
40
 
        int format;
41
 
        int block_size;
42
 
        ADPCM adpcm;
43
 
 
44
 
        int bytes_per_frame;
45
 
        uint8* buffer;
46
 
        int buffer_frames;
47
 
 
48
 
        AudinReceive receive;
49
 
        void* user_data;
50
 
} AudinPulseDevice;
51
 
 
52
 
static void audin_pulse_context_state_callback(pa_context* context, void* userdata)
53
 
{
54
 
        pa_context_state_t state;
55
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) userdata;
56
 
 
57
 
        state = pa_context_get_state(context);
58
 
        switch (state)
59
 
        {
60
 
                case PA_CONTEXT_READY:
61
 
                        DEBUG_DVC("PA_CONTEXT_READY");
62
 
                        pa_threaded_mainloop_signal (pulse->mainloop, 0);
63
 
                        break;
64
 
 
65
 
                case PA_CONTEXT_FAILED:
66
 
                case PA_CONTEXT_TERMINATED:
67
 
                        DEBUG_DVC("state %d", (int)state);
68
 
                        pa_threaded_mainloop_signal (pulse->mainloop, 0);
69
 
                        break;
70
 
 
71
 
                default:
72
 
                        DEBUG_DVC("state %d", (int)state);
73
 
                        break;
74
 
        }
75
 
}
76
 
 
77
 
static boolean audin_pulse_connect(IAudinDevice* device)
78
 
{
79
 
        pa_context_state_t state;
80
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
81
 
 
82
 
        if (!pulse->context)
83
 
                return false;
84
 
 
85
 
        if (pa_context_connect(pulse->context, NULL, 0, NULL))
86
 
        {
87
 
                DEBUG_WARN("pa_context_connect failed (%d)",
88
 
                        pa_context_errno(pulse->context));
89
 
                return false;
90
 
        }
91
 
        pa_threaded_mainloop_lock(pulse->mainloop);
92
 
        if (pa_threaded_mainloop_start(pulse->mainloop) < 0)
93
 
        {
94
 
                pa_threaded_mainloop_unlock(pulse->mainloop);
95
 
                DEBUG_WARN("pa_threaded_mainloop_start failed (%d)",
96
 
                        pa_context_errno(pulse->context));
97
 
                return false;
98
 
        }
99
 
        for (;;)
100
 
        {
101
 
                state = pa_context_get_state(pulse->context);
102
 
                if (state == PA_CONTEXT_READY)
103
 
                        break;
104
 
                if (!PA_CONTEXT_IS_GOOD(state))
105
 
                {
106
 
                        DEBUG_WARN("bad context state (%d)",
107
 
                                pa_context_errno(pulse->context));
108
 
                        break;
109
 
                }
110
 
                pa_threaded_mainloop_wait(pulse->mainloop);
111
 
        }
112
 
        pa_threaded_mainloop_unlock(pulse->mainloop);
113
 
        if (state == PA_CONTEXT_READY)
114
 
        {
115
 
                DEBUG_DVC("connected");
116
 
                return true;
117
 
        }
118
 
        else
119
 
        {
120
 
                pa_context_disconnect(pulse->context);
121
 
                return false;
122
 
        }
123
 
}
124
 
 
125
 
static void audin_pulse_free(IAudinDevice* device)
126
 
{
127
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
128
 
 
129
 
        DEBUG_DVC("");
130
 
 
131
 
        if (!pulse)
132
 
                return;
133
 
        if (pulse->mainloop)
134
 
        {
135
 
                pa_threaded_mainloop_stop(pulse->mainloop);
136
 
        }
137
 
        if (pulse->context)
138
 
        {
139
 
                pa_context_disconnect(pulse->context);
140
 
                pa_context_unref(pulse->context);
141
 
                pulse->context = NULL;
142
 
        }
143
 
        if (pulse->mainloop)
144
 
        {
145
 
                pa_threaded_mainloop_free(pulse->mainloop);
146
 
                pulse->mainloop = NULL;
147
 
        }
148
 
        xfree(pulse);
149
 
}
150
 
 
151
 
static boolean audin_pulse_format_supported(IAudinDevice* device, audinFormat* format)
152
 
{
153
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
154
 
 
155
 
        if (!pulse->context)
156
 
                return 0;
157
 
 
158
 
        switch (format->wFormatTag)
159
 
        {
160
 
                case 1: /* PCM */
161
 
                        if (format->cbSize == 0 &&
162
 
                                (format->nSamplesPerSec <= PA_RATE_MAX) &&
163
 
                                (format->wBitsPerSample == 8 || format->wBitsPerSample == 16) &&
164
 
                                (format->nChannels >= 1 && format->nChannels <= PA_CHANNELS_MAX))
165
 
                        {
166
 
                                return true;
167
 
                        }
168
 
                        break;
169
 
 
170
 
                case 6: /* A-LAW */
171
 
                case 7: /* U-LAW */
172
 
                        if (format->cbSize == 0 &&
173
 
                                (format->nSamplesPerSec <= PA_RATE_MAX) &&
174
 
                                (format->wBitsPerSample == 8) &&
175
 
                                (format->nChannels >= 1 && format->nChannels <= PA_CHANNELS_MAX))
176
 
                        {
177
 
                                return true;
178
 
                        }
179
 
                        break;
180
 
 
181
 
                case 0x11: /* IMA ADPCM */
182
 
                        if ((format->nSamplesPerSec <= PA_RATE_MAX) &&
183
 
                                (format->wBitsPerSample == 4) &&
184
 
                                (format->nChannels == 1 || format->nChannels == 2))
185
 
                        {
186
 
                                return true;
187
 
                        }
188
 
                        break;
189
 
        }
190
 
        return false;
191
 
}
192
 
 
193
 
static void audin_pulse_set_format(IAudinDevice* device, audinFormat* format, uint32 FramesPerPacket)
194
 
{
195
 
        int bs;
196
 
        pa_sample_spec sample_spec = { 0 };
197
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
198
 
 
199
 
        if (!pulse->context)
200
 
                return;
201
 
 
202
 
        if (FramesPerPacket > 0)
203
 
        {
204
 
                pulse->frames_per_packet = FramesPerPacket;
205
 
        }
206
 
 
207
 
        sample_spec.rate = format->nSamplesPerSec;
208
 
        sample_spec.channels = format->nChannels;
209
 
        switch (format->wFormatTag)
210
 
        {
211
 
                case 1: /* PCM */
212
 
                        switch (format->wBitsPerSample)
213
 
                        {
214
 
                                case 8:
215
 
                                        sample_spec.format = PA_SAMPLE_U8;
216
 
                                        break;
217
 
                                case 16:
218
 
                                        sample_spec.format = PA_SAMPLE_S16LE;
219
 
                                        break;
220
 
                        }
221
 
                        break;
222
 
 
223
 
                case 6: /* A-LAW */
224
 
                        sample_spec.format = PA_SAMPLE_ALAW;
225
 
                        break;
226
 
 
227
 
                case 7: /* U-LAW */
228
 
                        sample_spec.format = PA_SAMPLE_ULAW;
229
 
                        break;
230
 
 
231
 
                case 0x11: /* IMA ADPCM */
232
 
                        sample_spec.format = PA_SAMPLE_S16LE;
233
 
                        bs = (format->nBlockAlign - 4 * format->nChannels) * 4;
234
 
                        pulse->frames_per_packet = (pulse->frames_per_packet * format->nChannels * 2 /
235
 
                                bs + 1) * bs / (format->nChannels * 2);
236
 
                        DEBUG_DVC("aligned FramesPerPacket=%d",
237
 
                                pulse->frames_per_packet);
238
 
                        break;
239
 
        }
240
 
 
241
 
        pulse->sample_spec = sample_spec;
242
 
        pulse->format = format->wFormatTag;
243
 
        pulse->block_size = format->nBlockAlign;
244
 
}
245
 
 
246
 
static void audin_pulse_stream_state_callback(pa_stream* stream, void* userdata)
247
 
{
248
 
        pa_stream_state_t state;
249
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) userdata;
250
 
 
251
 
        state = pa_stream_get_state(stream);
252
 
        switch (state)
253
 
        {
254
 
                case PA_STREAM_READY:
255
 
                        DEBUG_DVC("PA_STREAM_READY");
256
 
                        pa_threaded_mainloop_signal(pulse->mainloop, 0);
257
 
                        break;
258
 
 
259
 
                case PA_STREAM_FAILED:
260
 
                case PA_STREAM_TERMINATED:
261
 
                        DEBUG_DVC("state %d", (int)state);
262
 
                        pa_threaded_mainloop_signal(pulse->mainloop, 0);
263
 
                        break;
264
 
 
265
 
                default:
266
 
                        DEBUG_DVC("state %d", (int)state);
267
 
                        break;
268
 
        }
269
 
}
270
 
 
271
 
static void audin_pulse_stream_request_callback(pa_stream* stream, size_t length, void* userdata)
272
 
{
273
 
        int frames;
274
 
        int cframes;
275
 
        boolean ret;
276
 
        const void* data;
277
 
        const uint8* src;
278
 
        int encoded_size;
279
 
        uint8* encoded_data;
280
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) userdata;
281
 
 
282
 
        pa_stream_peek(stream, &data, &length);
283
 
        frames = length / pulse->bytes_per_frame;
284
 
 
285
 
        DEBUG_DVC("length %d frames %d", (int) length, frames);
286
 
 
287
 
        src = (const uint8*) data;
288
 
        while (frames > 0)
289
 
        {
290
 
                cframes = pulse->frames_per_packet - pulse->buffer_frames;
291
 
                if (cframes > frames)
292
 
                        cframes = frames;
293
 
                memcpy(pulse->buffer + pulse->buffer_frames * pulse->bytes_per_frame,
294
 
                        src, cframes * pulse->bytes_per_frame);
295
 
                pulse->buffer_frames += cframes;
296
 
                if (pulse->buffer_frames >= pulse->frames_per_packet)
297
 
                {
298
 
                        if (pulse->format == 0x11)
299
 
                        {
300
 
                                encoded_data = dsp_encode_ima_adpcm(&pulse->adpcm,
301
 
                                        pulse->buffer, pulse->buffer_frames * pulse->bytes_per_frame,
302
 
                                        pulse->sample_spec.channels, pulse->block_size, &encoded_size);
303
 
                                DEBUG_DVC("encoded %d to %d",
304
 
                                        pulse->buffer_frames * pulse->bytes_per_frame, encoded_size);
305
 
                        }
306
 
                        else
307
 
                        {
308
 
                                encoded_data = pulse->buffer;
309
 
                                encoded_size = pulse->buffer_frames * pulse->bytes_per_frame;
310
 
                        }
311
 
 
312
 
                        ret = pulse->receive(encoded_data, encoded_size, pulse->user_data);
313
 
                        pulse->buffer_frames = 0;
314
 
                        if (encoded_data != pulse->buffer)
315
 
                                xfree(encoded_data);
316
 
                        if (!ret)
317
 
                                break;
318
 
                }
319
 
                src += cframes * pulse->bytes_per_frame;
320
 
                frames -= cframes;
321
 
        }
322
 
 
323
 
        pa_stream_drop(stream);
324
 
}
325
 
 
326
 
 
327
 
static void audin_pulse_close(IAudinDevice* device)
328
 
{
329
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
330
 
 
331
 
        if (!pulse->context || !pulse->stream)
332
 
                return;
333
 
 
334
 
        DEBUG_DVC("");
335
 
 
336
 
        pa_threaded_mainloop_lock(pulse->mainloop);
337
 
        pa_stream_disconnect(pulse->stream);
338
 
        pa_stream_unref(pulse->stream);
339
 
        pulse->stream = NULL;
340
 
        pa_threaded_mainloop_unlock(pulse->mainloop);
341
 
 
342
 
        pulse->receive = NULL;
343
 
        pulse->user_data = NULL;
344
 
        if (pulse->buffer)
345
 
        {
346
 
                xfree(pulse->buffer);
347
 
                pulse->buffer = NULL;
348
 
                pulse->buffer_frames = 0;
349
 
        }
350
 
}
351
 
 
352
 
static void audin_pulse_open(IAudinDevice* device, AudinReceive receive, void* user_data)
353
 
{
354
 
        pa_stream_state_t state;
355
 
        pa_buffer_attr buffer_attr = { 0 };
356
 
        AudinPulseDevice* pulse = (AudinPulseDevice*) device;
357
 
 
358
 
        if (!pulse->context)
359
 
                return;
360
 
        if (!pulse->sample_spec.rate || pulse->stream)
361
 
                return;
362
 
 
363
 
        DEBUG_DVC("");
364
 
 
365
 
        pulse->receive = receive;
366
 
        pulse->user_data = user_data;
367
 
 
368
 
        pa_threaded_mainloop_lock(pulse->mainloop);
369
 
        pulse->stream = pa_stream_new(pulse->context, "freerdp_audin",
370
 
                &pulse->sample_spec, NULL);
371
 
        if (!pulse->stream)
372
 
        {
373
 
                pa_threaded_mainloop_unlock(pulse->mainloop);
374
 
                DEBUG_DVC("pa_stream_new failed (%d)",
375
 
                        pa_context_errno(pulse->context));
376
 
                return;
377
 
        }
378
 
        pulse->bytes_per_frame = pa_frame_size(&pulse->sample_spec);
379
 
        pa_stream_set_state_callback(pulse->stream,
380
 
                audin_pulse_stream_state_callback, pulse);
381
 
        pa_stream_set_read_callback(pulse->stream,
382
 
                audin_pulse_stream_request_callback, pulse);
383
 
        buffer_attr.maxlength = (uint32_t) -1;
384
 
        buffer_attr.tlength = (uint32_t) -1;
385
 
        buffer_attr.prebuf = (uint32_t) -1;
386
 
        buffer_attr.minreq = (uint32_t) -1;
387
 
        /* 500ms latency */
388
 
        buffer_attr.fragsize = pa_usec_to_bytes(500000, &pulse->sample_spec);
389
 
        if (pa_stream_connect_record(pulse->stream,
390
 
                pulse->device_name[0] ? pulse->device_name : NULL,
391
 
                &buffer_attr, PA_STREAM_ADJUST_LATENCY) < 0)
392
 
        {
393
 
                pa_threaded_mainloop_unlock(pulse->mainloop);
394
 
                DEBUG_WARN("pa_stream_connect_playback failed (%d)",
395
 
                        pa_context_errno(pulse->context));
396
 
                return;
397
 
        }
398
 
 
399
 
        for (;;)
400
 
        {
401
 
                state = pa_stream_get_state(pulse->stream);
402
 
                if (state == PA_STREAM_READY)
403
 
                        break;
404
 
                if (!PA_STREAM_IS_GOOD(state))
405
 
                {
406
 
                        DEBUG_WARN("bad stream state (%d)",
407
 
                                pa_context_errno(pulse->context));
408
 
                        break;
409
 
                }
410
 
                pa_threaded_mainloop_wait(pulse->mainloop);
411
 
        }
412
 
        pa_threaded_mainloop_unlock(pulse->mainloop);
413
 
        if (state == PA_STREAM_READY)
414
 
        {
415
 
                memset(&pulse->adpcm, 0, sizeof(ADPCM));
416
 
                pulse->buffer = xzalloc(pulse->bytes_per_frame * pulse->frames_per_packet);
417
 
                pulse->buffer_frames = 0;
418
 
                DEBUG_DVC("connected");
419
 
        }
420
 
        else
421
 
        {
422
 
                audin_pulse_close(device);
423
 
        }
424
 
}
425
 
 
426
 
int FreeRDPAudinDeviceEntry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
427
 
{
428
 
        AudinPulseDevice* pulse;
429
 
        RDP_PLUGIN_DATA * data;
430
 
 
431
 
        pulse = xnew(AudinPulseDevice);
432
 
 
433
 
        pulse->iface.Open = audin_pulse_open;
434
 
        pulse->iface.FormatSupported = audin_pulse_format_supported;
435
 
        pulse->iface.SetFormat = audin_pulse_set_format;
436
 
        pulse->iface.Close = audin_pulse_close;
437
 
        pulse->iface.Free = audin_pulse_free;
438
 
 
439
 
        data = pEntryPoints->plugin_data;
440
 
        if (data && data->data[0] && strcmp(data->data[0], "audin") == 0 &&
441
 
                data->data[1] && strcmp(data->data[1], "pulse") == 0)
442
 
        {
443
 
                strncpy(pulse->device_name, (char*)data->data[2], sizeof(pulse->device_name));
444
 
        }
445
 
 
446
 
        pulse->mainloop = pa_threaded_mainloop_new();
447
 
        if (!pulse->mainloop)
448
 
        {
449
 
                DEBUG_WARN("pa_threaded_mainloop_new failed");
450
 
                audin_pulse_free((IAudinDevice*) pulse);
451
 
                return 1;
452
 
        }
453
 
        pulse->context = pa_context_new(pa_threaded_mainloop_get_api(pulse->mainloop), "freerdp");
454
 
        if (!pulse->context)
455
 
        {
456
 
                DEBUG_WARN("pa_context_new failed");
457
 
                audin_pulse_free((IAudinDevice*) pulse);
458
 
                return 1;
459
 
        }
460
 
        pa_context_set_state_callback(pulse->context, audin_pulse_context_state_callback, pulse);
461
 
        if (!audin_pulse_connect((IAudinDevice*) pulse))
462
 
        {
463
 
                audin_pulse_free((IAudinDevice*) pulse);
464
 
                return 1;
465
 
        }
466
 
 
467
 
        pEntryPoints->pRegisterAudinDevice(pEntryPoints->plugin, (IAudinDevice*) pulse);
468
 
 
469
 
        return 0;
470
 
}
471