1/***
2  This file is part of PulseAudio.
3
4  PulseAudio is free software; you can redistribute it and/or modify
5  it under the terms of the GNU Lesser General Public License as published
6  by the Free Software Foundation; either version 2.1 of the License,
7  or (at your option) any later version.
8
9  PulseAudio is distributed in the hope that it will be useful, but
10  WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  General Public License for more details.
13
14  You should have received a copy of the GNU Lesser General Public License
15  along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
16***/
17
18#ifdef HAVE_CONFIG_H
19#include <config.h>
20#endif
21
22#include <signal.h>
23#include <errno.h>
24#include <unistd.h>
25#include <assert.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <math.h>
29
30#include <check.h>
31
32#include <pulse/pulseaudio.h>
33#include <pulse/mainloop.h>
34#include <pulsecore/macro.h>
35
36#define NSTREAMS 4
37#define SINE_HZ 440
38#define SAMPLE_HZ 8000
39
40static pa_context *context = NULL;
41static pa_stream *streams[NSTREAMS];
42static pa_mainloop_api *mainloop_api = NULL;
43static const char *bname = NULL;
44
45static float data[SAMPLE_HZ]; /* one second space */
46
47static int n_streams_ready = 0;
48
49static const pa_sample_spec sample_spec = {
50    .format = PA_SAMPLE_FLOAT32,
51    .rate = SAMPLE_HZ,
52    .channels = 1
53};
54
55static const pa_buffer_attr buffer_attr = {
56    .maxlength = SAMPLE_HZ*sizeof(float)*NSTREAMS, /* exactly space for the entire play time */
57    .tlength = (uint32_t) -1,
58    .prebuf = 0, /* Setting prebuf to 0 guarantees us the streams will run synchronously, no matter what */
59    .minreq = (uint32_t) -1,
60    .fragsize = 0
61};
62
63static void nop_free_cb(void *p) {}
64
65static void underflow_cb(struct pa_stream *s, void *userdata) {
66    int i = PA_PTR_TO_INT(userdata);
67
68    fprintf(stderr, "Stream %i finished\n", i);
69
70    if (++n_streams_ready >= 2*NSTREAMS) {
71        fprintf(stderr, "We're done\n");
72        mainloop_api->quit(mainloop_api, 0);
73    }
74}
75
76/* This routine is called whenever the stream state changes */
77static void stream_state_callback(pa_stream *s, void *userdata) {
78    fail_unless(s != NULL);
79
80    switch (pa_stream_get_state(s)) {
81        case PA_STREAM_UNCONNECTED:
82        case PA_STREAM_CREATING:
83        case PA_STREAM_TERMINATED:
84            break;
85
86        case PA_STREAM_READY: {
87
88            int r, i = PA_PTR_TO_INT(userdata);
89
90            fprintf(stderr, "Writing data to stream %i.\n", i);
91
92            r = pa_stream_write(s, data, sizeof(data), nop_free_cb, (int64_t) sizeof(data) * (int64_t) i, PA_SEEK_ABSOLUTE);
93            fail_unless(r == 0);
94
95            /* Be notified when this stream is drained */
96            pa_stream_set_underflow_callback(s, underflow_cb, userdata);
97
98            /* All streams have been set up, let's go! */
99            if (++n_streams_ready >= NSTREAMS) {
100                fprintf(stderr, "Uncorking\n");
101                pa_operation_unref(pa_stream_cork(s, 0, NULL, NULL));
102            }
103
104            break;
105        }
106
107        default:
108        case PA_STREAM_FAILED:
109            fprintf(stderr, "Stream error: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
110            ck_abort();
111    }
112}
113
114/* This is called whenever the context status changes */
115static void context_state_callback(pa_context *c, void *userdata) {
116    fail_unless(c != NULL);
117
118    switch (pa_context_get_state(c)) {
119        case PA_CONTEXT_CONNECTING:
120        case PA_CONTEXT_AUTHORIZING:
121        case PA_CONTEXT_SETTING_NAME:
122            break;
123
124        case PA_CONTEXT_READY: {
125
126            int i;
127            fprintf(stderr, "Connection established.\n");
128
129            for (i = 0; i < NSTREAMS; i++) {
130                char name[64];
131
132                fprintf(stderr, "Creating stream %i\n", i);
133
134                snprintf(name, sizeof(name), "stream #%i", i);
135
136                streams[i] = pa_stream_new(c, name, &sample_spec, NULL);
137                fail_unless(streams[i] != NULL);
138                pa_stream_set_state_callback(streams[i], stream_state_callback, PA_INT_TO_PTR(i));
139                pa_stream_connect_playback(streams[i], NULL, &buffer_attr, PA_STREAM_START_CORKED, NULL, i == 0 ? NULL : streams[0]);
140            }
141
142            break;
143        }
144
145        case PA_CONTEXT_TERMINATED:
146            mainloop_api->quit(mainloop_api, 0);
147            break;
148
149        case PA_CONTEXT_FAILED:
150        default:
151            fprintf(stderr, "Context error: %s\n", pa_strerror(pa_context_errno(c)));
152            ck_abort();
153    }
154}
155
156START_TEST (sync_playback_test) {
157    pa_mainloop* m = NULL;
158    int i, ret = 0;
159
160    for (i = 0; i < SAMPLE_HZ; i++)
161        data[i] = (float) sin(((double) i/SAMPLE_HZ)*2*M_PI*SINE_HZ)/2;
162
163    for (i = 0; i < NSTREAMS; i++)
164        streams[i] = NULL;
165
166    /* Set up a new main loop */
167    m = pa_mainloop_new();
168    fail_unless(m != NULL);
169
170    mainloop_api = pa_mainloop_get_api(m);
171
172    context = pa_context_new(mainloop_api, bname);
173    fail_unless(context != NULL);
174
175    pa_context_set_state_callback(context, context_state_callback, NULL);
176
177    /* Connect the context */
178    if (pa_context_connect(context, NULL, 0, NULL) < 0) {
179        fprintf(stderr, "pa_context_connect() failed.\n");
180        goto quit;
181    }
182
183    if (pa_mainloop_run(m, &ret) < 0)
184        fprintf(stderr, "pa_mainloop_run() failed.\n");
185
186quit:
187    pa_context_unref(context);
188
189    for (i = 0; i < NSTREAMS; i++)
190        if (streams[i])
191            pa_stream_unref(streams[i]);
192
193    pa_mainloop_free(m);
194
195    fail_unless(ret == 0);
196}
197END_TEST
198
199int main(int argc, char *argv[]) {
200    int failed = 0;
201    Suite *s;
202    TCase *tc;
203    SRunner *sr;
204
205    bname = argv[0];
206
207    s = suite_create("Sync Playback");
208    tc = tcase_create("syncplayback");
209    tcase_add_test(tc, sync_playback_test);
210    /* 4s of audio, 0.5s grace time */
211    tcase_set_timeout(tc, 4.5);
212    suite_add_tcase(s, tc);
213
214    sr = srunner_create(s);
215    srunner_run_all(sr, CK_NORMAL);
216    failed = srunner_ntests_failed(sr);
217    srunner_free(sr);
218
219    return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
220}
221