avdevice/lavfi: Use av_malloc_array()
[ffmpeg.git] / libavdevice / pulse_audio_enc.c
1 /*
2  * Copyright (c) 2013 Lukasz Marek <lukasz.m.luki@gmail.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <math.h>
22 #include <pulse/pulseaudio.h>
23 #include <pulse/error.h>
24 #include "libavformat/avformat.h"
25 #include "libavformat/internal.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/time.h"
28 #include "libavutil/log.h"
29 #include "libavutil/attributes.h"
30 #include "pulse_audio_common.h"
31
32 typedef struct PulseData {
33     AVClass *class;
34     const char *server;
35     const char *name;
36     const char *stream_name;
37     const char *device;
38     int64_t timestamp;
39     int buffer_size;               /**< Buffer size in bytes */
40     int buffer_duration;           /**< Buffer size in ms, recalculated to buffer_size */
41     int prebuf;
42     int minreq;
43     int last_result;
44     pa_threaded_mainloop *mainloop;
45     pa_context *ctx;
46     pa_stream *stream;
47     int nonblocking;
48     int mute;
49     pa_volume_t base_volume;
50     pa_volume_t last_volume;
51 } PulseData;
52
53 static void pulse_audio_sink_device_cb(pa_context *ctx, const pa_sink_info *dev,
54                                        int eol, void *userdata)
55 {
56     PulseData *s = userdata;
57
58     if (s->ctx != ctx)
59         return;
60
61     if (eol) {
62         pa_threaded_mainloop_signal(s->mainloop, 0);
63     } else {
64         if (dev->flags & PA_SINK_FLAT_VOLUME)
65             s->base_volume = dev->base_volume;
66         else
67             s->base_volume = PA_VOLUME_NORM;
68         av_log(s, AV_LOG_DEBUG, "base volume: %u\n", s->base_volume);
69     }
70 }
71
72 /* Mainloop must be locked before calling this function as it uses pa_threaded_mainloop_wait. */
73 static int pulse_update_sink_info(AVFormatContext *h)
74 {
75     PulseData *s = h->priv_data;
76     pa_operation *op;
77     if (!(op = pa_context_get_sink_info_by_name(s->ctx, s->device,
78                                                 pulse_audio_sink_device_cb, s))) {
79         av_log(s, AV_LOG_ERROR, "pa_context_get_sink_info_by_name failed.\n");
80         return AVERROR_EXTERNAL;
81     }
82     while (pa_operation_get_state(op) == PA_OPERATION_RUNNING)
83         pa_threaded_mainloop_wait(s->mainloop);
84     pa_operation_unref(op);
85     return 0;
86 }
87
88 static void pulse_audio_sink_input_cb(pa_context *ctx, const pa_sink_input_info *i,
89                                       int eol, void *userdata)
90 {
91     AVFormatContext *h = userdata;
92     PulseData *s = h->priv_data;
93
94     if (s->ctx != ctx)
95         return;
96
97     if (!eol) {
98         double val;
99         pa_volume_t vol = pa_cvolume_avg(&i->volume);
100         if (s->mute < 0 || (s->mute && !i->mute) || (!s->mute && i->mute)) {
101             s->mute = i->mute;
102             avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_MUTE_STATE_CHANGED, &s->mute, sizeof(s->mute));
103         }
104
105         vol = pa_sw_volume_divide(vol, s->base_volume);
106         if (s->last_volume != vol) {
107             val = (double)vol / PA_VOLUME_NORM;
108             avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED, &val, sizeof(val));
109             s->last_volume = vol;
110         }
111     }
112 }
113
114 /* This function creates new loop so may be called from PA callbacks.
115    Mainloop must be locked before calling this function as it operates on streams. */
116 static int pulse_update_sink_input_info(AVFormatContext *h)
117 {
118     PulseData *s = h->priv_data;
119     pa_operation *op;
120     enum pa_operation_state op_state;
121     pa_mainloop *ml = NULL;
122     pa_context *ctx = NULL;
123     int ret = 0;
124
125     if ((ret = ff_pulse_audio_connect_context(&ml, &ctx, s->server, "Update sink input information")) < 0)
126         return ret;
127
128     if (!(op = pa_context_get_sink_input_info(ctx, pa_stream_get_index(s->stream),
129                                               pulse_audio_sink_input_cb, h))) {
130         ret = AVERROR_EXTERNAL;
131         goto fail;
132     }
133
134     while ((op_state = pa_operation_get_state(op)) == PA_OPERATION_RUNNING)
135         pa_mainloop_iterate(ml, 1, NULL);
136     pa_operation_unref(op);
137     if (op_state != PA_OPERATION_DONE) {
138         ret = AVERROR_EXTERNAL;
139         goto fail;
140     }
141
142   fail:
143     ff_pulse_audio_disconnect_context(&ml, &ctx);
144     if (ret)
145         av_log(s, AV_LOG_ERROR, "pa_context_get_sink_input_info failed.\n");
146     return ret;
147 }
148
149 static void pulse_event(pa_context *ctx, pa_subscription_event_type_t t,
150                         uint32_t idx, void *userdata)
151 {
152     AVFormatContext *h = userdata;
153     PulseData *s = h->priv_data;
154
155     if (s->ctx != ctx)
156         return;
157
158     if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK_INPUT) {
159         if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_CHANGE)
160             // Calling from mainloop callback. No need to lock mainloop.
161             pulse_update_sink_input_info(h);
162     }
163 }
164
165 static void pulse_stream_writable(pa_stream *stream, size_t nbytes, void *userdata)
166 {
167     AVFormatContext *h = userdata;
168     PulseData *s = h->priv_data;
169     int64_t val = nbytes;
170
171     if (stream != s->stream)
172         return;
173
174     avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_BUFFER_WRITABLE, &val, sizeof(val));
175     pa_threaded_mainloop_signal(s->mainloop, 0);
176 }
177
178 static void pulse_overflow(pa_stream *stream, void *userdata)
179 {
180     AVFormatContext *h = userdata;
181     avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_BUFFER_OVERFLOW, NULL, 0);
182 }
183
184 static void pulse_underflow(pa_stream *stream, void *userdata)
185 {
186     AVFormatContext *h = userdata;
187     avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_BUFFER_UNDERFLOW, NULL, 0);
188 }
189
190 static void pulse_stream_state(pa_stream *stream, void *userdata)
191 {
192     PulseData *s = userdata;
193
194     if (stream != s->stream)
195         return;
196
197     switch (pa_stream_get_state(s->stream)) {
198         case PA_STREAM_READY:
199         case PA_STREAM_FAILED:
200         case PA_STREAM_TERMINATED:
201             pa_threaded_mainloop_signal(s->mainloop, 0);
202         default:
203             break;
204     }
205 }
206
207 static int pulse_stream_wait(PulseData *s)
208 {
209     pa_stream_state_t state;
210
211     while ((state = pa_stream_get_state(s->stream)) != PA_STREAM_READY) {
212         if (state == PA_STREAM_FAILED || state == PA_STREAM_TERMINATED)
213             return AVERROR_EXTERNAL;
214         pa_threaded_mainloop_wait(s->mainloop);
215     }
216     return 0;
217 }
218
219 static void pulse_context_state(pa_context *ctx, void *userdata)
220 {
221     PulseData *s = userdata;
222
223     if (s->ctx != ctx)
224         return;
225
226     switch (pa_context_get_state(ctx)) {
227         case PA_CONTEXT_READY:
228         case PA_CONTEXT_FAILED:
229         case PA_CONTEXT_TERMINATED:
230             pa_threaded_mainloop_signal(s->mainloop, 0);
231         default:
232             break;
233     }
234 }
235
236 static int pulse_context_wait(PulseData *s)
237 {
238     pa_context_state_t state;
239
240     while ((state = pa_context_get_state(s->ctx)) != PA_CONTEXT_READY) {
241         if (state == PA_CONTEXT_FAILED || state == PA_CONTEXT_TERMINATED)
242             return AVERROR_EXTERNAL;
243         pa_threaded_mainloop_wait(s->mainloop);
244     }
245     return 0;
246 }
247
248 static void pulse_stream_result(pa_stream *stream, int success, void *userdata)
249 {
250     PulseData *s = userdata;
251
252     if (stream != s->stream)
253         return;
254
255     s->last_result = success ? 0 : AVERROR_EXTERNAL;
256     pa_threaded_mainloop_signal(s->mainloop, 0);
257 }
258
259 static int pulse_finish_stream_operation(PulseData *s, pa_operation *op, const char *name)
260 {
261     if (!op) {
262         pa_threaded_mainloop_unlock(s->mainloop);
263         av_log(s, AV_LOG_ERROR, "%s failed.\n", name);
264         return AVERROR_EXTERNAL;
265     }
266     s->last_result = 2;
267     while (s->last_result == 2)
268         pa_threaded_mainloop_wait(s->mainloop);
269     pa_operation_unref(op);
270     pa_threaded_mainloop_unlock(s->mainloop);
271     if (s->last_result != 0)
272         av_log(s, AV_LOG_ERROR, "%s failed.\n", name);
273     return s->last_result;
274 }
275
276 static int pulse_set_pause(PulseData *s, int pause)
277 {
278     pa_operation *op;
279     pa_threaded_mainloop_lock(s->mainloop);
280     op = pa_stream_cork(s->stream, pause, pulse_stream_result, s);
281     return pulse_finish_stream_operation(s, op, "pa_stream_cork");
282 }
283
284 static int pulse_flash_stream(PulseData *s)
285 {
286     pa_operation *op;
287     pa_threaded_mainloop_lock(s->mainloop);
288     op = pa_stream_flush(s->stream, pulse_stream_result, s);
289     return pulse_finish_stream_operation(s, op, "pa_stream_flush");
290 }
291
292 static void pulse_context_result(pa_context *ctx, int success, void *userdata)
293 {
294     PulseData *s = userdata;
295
296     if (s->ctx != ctx)
297         return;
298
299     s->last_result = success ? 0 : AVERROR_EXTERNAL;
300     pa_threaded_mainloop_signal(s->mainloop, 0);
301 }
302
303 static int pulse_finish_context_operation(PulseData *s, pa_operation *op, const char *name)
304 {
305     if (!op) {
306         pa_threaded_mainloop_unlock(s->mainloop);
307         av_log(s, AV_LOG_ERROR, "%s failed.\n", name);
308         return AVERROR_EXTERNAL;
309     }
310     s->last_result = 2;
311     while (s->last_result == 2)
312         pa_threaded_mainloop_wait(s->mainloop);
313     pa_operation_unref(op);
314     pa_threaded_mainloop_unlock(s->mainloop);
315     if (s->last_result != 0)
316         av_log(s, AV_LOG_ERROR, "%s failed.\n", name);
317     return s->last_result;
318 }
319
320 static int pulse_set_mute(PulseData *s)
321 {
322     pa_operation *op;
323     pa_threaded_mainloop_lock(s->mainloop);
324     op = pa_context_set_sink_input_mute(s->ctx, pa_stream_get_index(s->stream),
325                                         s->mute, pulse_context_result, s);
326     return pulse_finish_context_operation(s, op, "pa_context_set_sink_input_mute");
327 }
328
329 static int pulse_set_volume(PulseData *s, double volume)
330 {
331     pa_operation *op;
332     pa_cvolume cvol;
333     pa_volume_t vol;
334     const pa_sample_spec *ss = pa_stream_get_sample_spec(s->stream);
335
336     vol = pa_sw_volume_multiply(lround(volume * PA_VOLUME_NORM), s->base_volume);
337     pa_cvolume_set(&cvol, ss->channels, PA_VOLUME_NORM);
338     pa_sw_cvolume_multiply_scalar(&cvol, &cvol, vol);
339     pa_threaded_mainloop_lock(s->mainloop);
340     op = pa_context_set_sink_input_volume(s->ctx, pa_stream_get_index(s->stream),
341                                           &cvol, pulse_context_result, s);
342     return pulse_finish_context_operation(s, op, "pa_context_set_sink_input_volume");
343 }
344
345 static int pulse_subscribe_events(PulseData *s)
346 {
347     pa_operation *op;
348
349     pa_threaded_mainloop_lock(s->mainloop);
350     op = pa_context_subscribe(s->ctx, PA_SUBSCRIPTION_MASK_SINK_INPUT, pulse_context_result, s);
351     return pulse_finish_context_operation(s, op, "pa_context_subscribe");
352 }
353
354 static void pulse_map_channels_to_pulse(int64_t channel_layout, pa_channel_map *channel_map)
355 {
356     channel_map->channels = 0;
357     if (channel_layout & AV_CH_FRONT_LEFT)
358         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_LEFT;
359     if (channel_layout & AV_CH_FRONT_RIGHT)
360         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_RIGHT;
361     if (channel_layout & AV_CH_FRONT_CENTER)
362         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_CENTER;
363     if (channel_layout & AV_CH_LOW_FREQUENCY)
364         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_LFE;
365     if (channel_layout & AV_CH_BACK_LEFT)
366         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_REAR_LEFT;
367     if (channel_layout & AV_CH_BACK_RIGHT)
368         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_REAR_RIGHT;
369     if (channel_layout & AV_CH_FRONT_LEFT_OF_CENTER)
370         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
371     if (channel_layout & AV_CH_FRONT_RIGHT_OF_CENTER)
372         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
373     if (channel_layout & AV_CH_BACK_CENTER)
374         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_REAR_CENTER;
375     if (channel_layout & AV_CH_SIDE_LEFT)
376         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_SIDE_LEFT;
377     if (channel_layout & AV_CH_SIDE_RIGHT)
378         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_SIDE_RIGHT;
379     if (channel_layout & AV_CH_TOP_CENTER)
380         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_CENTER;
381     if (channel_layout & AV_CH_TOP_FRONT_LEFT)
382         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
383     if (channel_layout & AV_CH_TOP_FRONT_CENTER)
384         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
385     if (channel_layout & AV_CH_TOP_FRONT_RIGHT)
386         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
387     if (channel_layout & AV_CH_TOP_BACK_LEFT)
388         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_REAR_LEFT;
389     if (channel_layout & AV_CH_TOP_BACK_CENTER)
390         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_REAR_CENTER;
391     if (channel_layout & AV_CH_TOP_BACK_RIGHT)
392         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
393     if (channel_layout & AV_CH_STEREO_LEFT)
394         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_LEFT;
395     if (channel_layout & AV_CH_STEREO_RIGHT)
396         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_FRONT_RIGHT;
397     if (channel_layout & AV_CH_WIDE_LEFT)
398         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_AUX0;
399     if (channel_layout & AV_CH_WIDE_RIGHT)
400         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_AUX1;
401     if (channel_layout & AV_CH_SURROUND_DIRECT_LEFT)
402         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_AUX2;
403     if (channel_layout & AV_CH_SURROUND_DIRECT_RIGHT)
404         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_AUX3;
405     if (channel_layout & AV_CH_LOW_FREQUENCY_2)
406         channel_map->map[channel_map->channels++] = PA_CHANNEL_POSITION_LFE;
407 }
408
409 static av_cold int pulse_write_trailer(AVFormatContext *h)
410 {
411     PulseData *s = h->priv_data;
412
413     if (s->mainloop) {
414         pa_threaded_mainloop_lock(s->mainloop);
415         if (s->stream) {
416             pa_stream_disconnect(s->stream);
417             pa_stream_set_state_callback(s->stream, NULL, NULL);
418             pa_stream_set_write_callback(s->stream, NULL, NULL);
419             pa_stream_set_overflow_callback(s->stream, NULL, NULL);
420             pa_stream_set_underflow_callback(s->stream, NULL, NULL);
421             pa_stream_unref(s->stream);
422             s->stream = NULL;
423         }
424         if (s->ctx) {
425             pa_context_disconnect(s->ctx);
426             pa_context_set_state_callback(s->ctx, NULL, NULL);
427             pa_context_set_subscribe_callback(s->ctx, NULL, NULL);
428             pa_context_unref(s->ctx);
429             s->ctx = NULL;
430         }
431         pa_threaded_mainloop_unlock(s->mainloop);
432         pa_threaded_mainloop_stop(s->mainloop);
433         pa_threaded_mainloop_free(s->mainloop);
434         s->mainloop = NULL;
435     }
436
437     return 0;
438 }
439
440 static av_cold int pulse_write_header(AVFormatContext *h)
441 {
442     PulseData *s = h->priv_data;
443     AVStream *st = NULL;
444     int ret;
445     pa_sample_spec sample_spec;
446     pa_buffer_attr buffer_attributes = { -1, -1, -1, -1, -1 };
447     pa_channel_map channel_map;
448     pa_mainloop_api *mainloop_api;
449     const char *stream_name = s->stream_name;
450     static const pa_stream_flags_t stream_flags = PA_STREAM_INTERPOLATE_TIMING |
451                                                   PA_STREAM_AUTO_TIMING_UPDATE |
452                                                   PA_STREAM_NOT_MONOTONIC;
453
454     if (h->nb_streams != 1 || h->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
455         av_log(s, AV_LOG_ERROR, "Only a single audio stream is supported.\n");
456         return AVERROR(EINVAL);
457     }
458     st = h->streams[0];
459
460     if (!stream_name) {
461         if (h->filename[0])
462             stream_name = h->filename;
463         else
464             stream_name = "Playback";
465     }
466     s->nonblocking = (h->flags & AVFMT_FLAG_NONBLOCK);
467
468     if (s->buffer_duration) {
469         int64_t bytes = s->buffer_duration;
470         bytes *= st->codec->channels * st->codec->sample_rate *
471                  av_get_bytes_per_sample(st->codec->sample_fmt);
472         bytes /= 1000;
473         buffer_attributes.tlength = FFMAX(s->buffer_size, av_clip64(bytes, 0, UINT32_MAX - 1));
474         av_log(s, AV_LOG_DEBUG,
475                "Buffer duration: %ums recalculated into %"PRId64" bytes buffer.\n",
476                s->buffer_duration, bytes);
477         av_log(s, AV_LOG_DEBUG, "Real buffer length is %u bytes\n", buffer_attributes.tlength);
478     } else if (s->buffer_size)
479         buffer_attributes.tlength = s->buffer_size;
480     if (s->prebuf)
481         buffer_attributes.prebuf = s->prebuf;
482     if (s->minreq)
483         buffer_attributes.minreq = s->minreq;
484
485     sample_spec.format = ff_codec_id_to_pulse_format(st->codec->codec_id);
486     sample_spec.rate = st->codec->sample_rate;
487     sample_spec.channels = st->codec->channels;
488     if (!pa_sample_spec_valid(&sample_spec)) {
489         av_log(s, AV_LOG_ERROR, "Invalid sample spec.\n");
490         return AVERROR(EINVAL);
491     }
492
493     if (sample_spec.channels == 1) {
494         channel_map.channels = 1;
495         channel_map.map[0] = PA_CHANNEL_POSITION_MONO;
496     } else if (st->codec->channel_layout) {
497         if (av_get_channel_layout_nb_channels(st->codec->channel_layout) != st->codec->channels)
498             return AVERROR(EINVAL);
499         pulse_map_channels_to_pulse(st->codec->channel_layout, &channel_map);
500         /* Unknown channel is present in channel_layout, let PulseAudio use its default. */
501         if (channel_map.channels != sample_spec.channels) {
502             av_log(s, AV_LOG_WARNING, "Unknown channel. Using defaul channel map.\n");
503             channel_map.channels = 0;
504         }
505     } else
506         channel_map.channels = 0;
507
508     if (!channel_map.channels)
509         av_log(s, AV_LOG_WARNING, "Using PulseAudio's default channel map.\n");
510     else if (!pa_channel_map_valid(&channel_map)) {
511         av_log(s, AV_LOG_ERROR, "Invalid channel map.\n");
512         return AVERROR(EINVAL);
513     }
514
515     /* start main loop */
516     s->mainloop = pa_threaded_mainloop_new();
517     if (!s->mainloop) {
518         av_log(s, AV_LOG_ERROR, "Cannot create threaded mainloop.\n");
519         return AVERROR(ENOMEM);
520     }
521     if ((ret = pa_threaded_mainloop_start(s->mainloop)) < 0) {
522         av_log(s, AV_LOG_ERROR, "Cannot start threaded mainloop: %s.\n", pa_strerror(ret));
523         pa_threaded_mainloop_free(s->mainloop);
524         s->mainloop = NULL;
525         return AVERROR_EXTERNAL;
526     }
527
528     pa_threaded_mainloop_lock(s->mainloop);
529
530     mainloop_api = pa_threaded_mainloop_get_api(s->mainloop);
531     if (!mainloop_api) {
532         av_log(s, AV_LOG_ERROR, "Cannot get mainloop API.\n");
533         ret = AVERROR_EXTERNAL;
534         goto fail;
535     }
536
537     s->ctx = pa_context_new(mainloop_api, s->name);
538     if (!s->ctx) {
539         av_log(s, AV_LOG_ERROR, "Cannot create context.\n");
540         ret = AVERROR(ENOMEM);
541         goto fail;
542     }
543     pa_context_set_state_callback(s->ctx, pulse_context_state, s);
544     pa_context_set_subscribe_callback(s->ctx, pulse_event, h);
545
546     if ((ret = pa_context_connect(s->ctx, s->server, 0, NULL)) < 0) {
547         av_log(s, AV_LOG_ERROR, "Cannot connect context: %s.\n", pa_strerror(ret));
548         ret = AVERROR_EXTERNAL;
549         goto fail;
550     }
551
552     if ((ret = pulse_context_wait(s)) < 0) {
553         av_log(s, AV_LOG_ERROR, "Context failed.\n");
554         goto fail;
555     }
556
557     s->stream = pa_stream_new(s->ctx, stream_name, &sample_spec,
558                               channel_map.channels ? &channel_map : NULL);
559
560     if ((ret = pulse_update_sink_info(h)) < 0) {
561         av_log(s, AV_LOG_ERROR, "Updating sink info failed.\n");
562         goto fail;
563     }
564
565     if (!s->stream) {
566         av_log(s, AV_LOG_ERROR, "Cannot create stream.\n");
567         ret = AVERROR(ENOMEM);
568         goto fail;
569     }
570     pa_stream_set_state_callback(s->stream, pulse_stream_state, s);
571     pa_stream_set_write_callback(s->stream, pulse_stream_writable, h);
572     pa_stream_set_overflow_callback(s->stream, pulse_overflow, h);
573     pa_stream_set_underflow_callback(s->stream, pulse_underflow, h);
574
575     if ((ret = pa_stream_connect_playback(s->stream, s->device, &buffer_attributes,
576                                           stream_flags, NULL, NULL)) < 0) {
577         av_log(s, AV_LOG_ERROR, "pa_stream_connect_playback failed: %s.\n", pa_strerror(ret));
578         ret = AVERROR_EXTERNAL;
579         goto fail;
580     }
581
582     if ((ret = pulse_stream_wait(s)) < 0) {
583         av_log(s, AV_LOG_ERROR, "Stream failed.\n");
584         goto fail;
585     }
586
587     /* read back buffer attributes for future use */
588     buffer_attributes = *pa_stream_get_buffer_attr(s->stream);
589     s->buffer_size = buffer_attributes.tlength;
590     s->prebuf = buffer_attributes.prebuf;
591     s->minreq = buffer_attributes.minreq;
592     av_log(s, AV_LOG_DEBUG, "Real buffer attributes: size: %d, prebuf: %d, minreq: %d\n",
593            s->buffer_size, s->prebuf, s->minreq);
594
595     pa_threaded_mainloop_unlock(s->mainloop);
596
597     if ((ret = pulse_subscribe_events(s)) < 0) {
598         av_log(s, AV_LOG_ERROR, "Event subscription failed.\n");
599         /* a bit ugly but the simplest to lock here*/
600         pa_threaded_mainloop_lock(s->mainloop);
601         goto fail;
602     }
603
604     /* force control messages */
605     s->mute = -1;
606     s->last_volume = PA_VOLUME_INVALID;
607     pa_threaded_mainloop_lock(s->mainloop);
608     if ((ret = pulse_update_sink_input_info(h)) < 0) {
609         av_log(s, AV_LOG_ERROR, "Updating sink input info failed.\n");
610         goto fail;
611     }
612     pa_threaded_mainloop_unlock(s->mainloop);
613
614     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
615
616     return 0;
617   fail:
618     pa_threaded_mainloop_unlock(s->mainloop);
619     pulse_write_trailer(h);
620     return ret;
621 }
622
623 static int pulse_write_packet(AVFormatContext *h, AVPacket *pkt)
624 {
625     PulseData *s = h->priv_data;
626     int ret;
627     int64_t writable_size;
628
629     if (!pkt)
630         return pulse_flash_stream(s);
631
632     if (pkt->dts != AV_NOPTS_VALUE)
633         s->timestamp = pkt->dts;
634
635     if (pkt->duration) {
636         s->timestamp += pkt->duration;
637     } else {
638         AVStream *st = h->streams[0];
639         AVCodecContext *codec_ctx = st->codec;
640         AVRational r = { 1, codec_ctx->sample_rate };
641         int64_t samples = pkt->size / (av_get_bytes_per_sample(codec_ctx->sample_fmt) * codec_ctx->channels);
642         s->timestamp += av_rescale_q(samples, r, st->time_base);
643     }
644
645     pa_threaded_mainloop_lock(s->mainloop);
646     if (!PA_STREAM_IS_GOOD(pa_stream_get_state(s->stream))) {
647         av_log(s, AV_LOG_ERROR, "PulseAudio stream is in invalid state.\n");
648         goto fail;
649     }
650     while (pa_stream_writable_size(s->stream) < s->minreq) {
651         if (s->nonblocking) {
652             pa_threaded_mainloop_unlock(s->mainloop);
653             return AVERROR(EAGAIN);
654         } else
655             pa_threaded_mainloop_wait(s->mainloop);
656     }
657
658     if ((ret = pa_stream_write(s->stream, pkt->data, pkt->size, NULL, 0, PA_SEEK_RELATIVE)) < 0) {
659         av_log(s, AV_LOG_ERROR, "pa_stream_write failed: %s\n", pa_strerror(ret));
660         goto fail;
661     }
662     if ((writable_size = pa_stream_writable_size(s->stream)) >= s->minreq)
663         avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_BUFFER_WRITABLE, &writable_size, sizeof(writable_size));
664
665     pa_threaded_mainloop_unlock(s->mainloop);
666
667     return 0;
668   fail:
669     pa_threaded_mainloop_unlock(s->mainloop);
670     return AVERROR_EXTERNAL;
671 }
672
673 static int pulse_write_frame(AVFormatContext *h, int stream_index,
674                              AVFrame **frame, unsigned flags)
675 {
676     AVPacket pkt;
677
678     /* Planar formats are not supported yet. */
679     if (flags & AV_WRITE_UNCODED_FRAME_QUERY)
680         return av_sample_fmt_is_planar(h->streams[stream_index]->codec->sample_fmt) ?
681                AVERROR(EINVAL) : 0;
682
683     pkt.data     = (*frame)->data[0];
684     pkt.size     = (*frame)->nb_samples * av_get_bytes_per_sample((*frame)->format) * (*frame)->channels;
685     pkt.dts      = (*frame)->pkt_dts;
686     pkt.duration = av_frame_get_pkt_duration(*frame);
687     return pulse_write_packet(h, &pkt);
688 }
689
690
691 static void pulse_get_output_timestamp(AVFormatContext *h, int stream, int64_t *dts, int64_t *wall)
692 {
693     PulseData *s = h->priv_data;
694     pa_usec_t latency;
695     int neg;
696     pa_threaded_mainloop_lock(s->mainloop);
697     pa_stream_get_latency(s->stream, &latency, &neg);
698     pa_threaded_mainloop_unlock(s->mainloop);
699     if (wall)
700         *wall = av_gettime();
701     if (dts)
702         *dts = s->timestamp - (neg ? -latency : latency);
703 }
704
705 static int pulse_get_device_list(AVFormatContext *h, AVDeviceInfoList *device_list)
706 {
707     PulseData *s = h->priv_data;
708     return ff_pulse_audio_get_devices(device_list, s->server, 1);
709 }
710
711 static int pulse_control_message(AVFormatContext *h, int type,
712                                  void *data, size_t data_size)
713 {
714     PulseData *s = h->priv_data;
715     int ret;
716
717     switch(type) {
718     case AV_APP_TO_DEV_PAUSE:
719         return pulse_set_pause(s, 1);
720     case AV_APP_TO_DEV_PLAY:
721         return pulse_set_pause(s, 0);
722     case AV_APP_TO_DEV_TOGGLE_PAUSE:
723         return pulse_set_pause(s, !pa_stream_is_corked(s->stream));
724     case AV_APP_TO_DEV_MUTE:
725         if (!s->mute) {
726             s->mute = 1;
727             return pulse_set_mute(s);
728         }
729         return 0;
730     case AV_APP_TO_DEV_UNMUTE:
731         if (s->mute) {
732             s->mute = 0;
733             return pulse_set_mute(s);
734         }
735         return 0;
736     case AV_APP_TO_DEV_TOGGLE_MUTE:
737         s->mute = !s->mute;
738         return pulse_set_mute(s);
739     case AV_APP_TO_DEV_SET_VOLUME:
740         return pulse_set_volume(s, *(double *)data);
741     case AV_APP_TO_DEV_GET_VOLUME:
742         s->last_volume = PA_VOLUME_INVALID;
743         pa_threaded_mainloop_lock(s->mainloop);
744         ret = pulse_update_sink_input_info(h);
745         pa_threaded_mainloop_unlock(s->mainloop);
746         return ret;
747     case AV_APP_TO_DEV_GET_MUTE:
748         s->mute = -1;
749         pa_threaded_mainloop_lock(s->mainloop);
750         ret = pulse_update_sink_input_info(h);
751         pa_threaded_mainloop_unlock(s->mainloop);
752         return ret;
753     default:
754         break;
755     }
756     return AVERROR(ENOSYS);
757 }
758
759 #define OFFSET(a) offsetof(PulseData, a)
760 #define E AV_OPT_FLAG_ENCODING_PARAM
761 static const AVOption options[] = {
762     { "server",          "set PulseAudio server",            OFFSET(server),          AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
763     { "name",            "set application name",             OFFSET(name),            AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT},  0, 0, E },
764     { "stream_name",     "set stream description",           OFFSET(stream_name),     AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
765     { "device",          "set device name",                  OFFSET(device),          AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
766     { "buffer_size",     "set buffer size in bytes",         OFFSET(buffer_size),     AV_OPT_TYPE_INT,    {.i64 = 0}, 0, INT_MAX, E },
767     { "buffer_duration", "set buffer duration in millisecs", OFFSET(buffer_duration), AV_OPT_TYPE_INT,    {.i64 = 0}, 0, INT_MAX, E },
768     { "prebuf",          "set pre-buffering size",           OFFSET(prebuf),          AV_OPT_TYPE_INT,    {.i64 = 0}, 0, INT_MAX, E },
769     { "minreq",          "set minimum request size",         OFFSET(minreq),          AV_OPT_TYPE_INT,    {.i64 = 0}, 0, INT_MAX, E },
770     { NULL }
771 };
772
773 static const AVClass pulse_muxer_class = {
774     .class_name     = "PulseAudio muxer",
775     .item_name      = av_default_item_name,
776     .option         = options,
777     .version        = LIBAVUTIL_VERSION_INT,
778     .category       = AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
779 };
780
781 AVOutputFormat ff_pulse_muxer = {
782     .name                 = "pulse",
783     .long_name            = NULL_IF_CONFIG_SMALL("Pulse audio output"),
784     .priv_data_size       = sizeof(PulseData),
785     .audio_codec          = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE),
786     .video_codec          = AV_CODEC_ID_NONE,
787     .write_header         = pulse_write_header,
788     .write_packet         = pulse_write_packet,
789     .write_uncoded_frame  = pulse_write_frame,
790     .write_trailer        = pulse_write_trailer,
791     .get_output_timestamp = pulse_get_output_timestamp,
792     .get_device_list      = pulse_get_device_list,
793     .control_message      = pulse_control_message,
794     .flags                = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH,
795     .priv_class           = &pulse_muxer_class,
796 };