[GStreamer] Adopt nullptr
[WebKit-https.git] / Source / WebCore / platform / audio / gstreamer / AudioSourceProviderGStreamer.cpp
1 /*
2  *  Copyright (C) 2014 Igalia S.L
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Lesser General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Lesser General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Lesser General Public
15  *  License along with this library; if not, write to the Free Software
16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #include "config.h"
20 #include "AudioSourceProviderGStreamer.h"
21
22 #if ENABLE(WEB_AUDIO) && ENABLE(VIDEO) && USE(GSTREAMER)
23
24 #include "AudioBus.h"
25 #include "AudioSourceProviderClient.h"
26 #include <gst/app/gstappsink.h>
27 #include <gst/audio/audio-info.h>
28 #include <gst/base/gstadapter.h>
29 #include <wtf/glib/GMutexLocker.h>
30
31
32 namespace WebCore {
33
34 // For now the provider supports only stereo files at a fixed sample
35 // bitrate.
36 static const int gNumberOfChannels = 2;
37 static const float gSampleBitRate = 44100;
38
39 static GstFlowReturn onAppsinkNewBufferCallback(GstAppSink* sink, gpointer userData)
40 {
41     return static_cast<AudioSourceProviderGStreamer*>(userData)->handleAudioBuffer(sink);
42 }
43
44 static void onGStreamerDeinterleavePadAddedCallback(GstElement*, GstPad* pad, AudioSourceProviderGStreamer* provider)
45 {
46     provider->handleNewDeinterleavePad(pad);
47 }
48
49 static void onGStreamerDeinterleaveReadyCallback(GstElement*, AudioSourceProviderGStreamer* provider)
50 {
51     provider->deinterleavePadsConfigured();
52 }
53
54 static void onGStreamerDeinterleavePadRemovedCallback(GstElement*, GstPad* pad, AudioSourceProviderGStreamer* provider)
55 {
56     provider->handleRemovedDeinterleavePad(pad);
57 }
58
59 static GstPadProbeReturn onAppsinkFlushCallback(GstPad*, GstPadProbeInfo* info, gpointer userData)
60 {
61     if (GST_PAD_PROBE_INFO_TYPE(info) & (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_EVENT_FLUSH)) {
62         GstEvent* event = GST_PAD_PROBE_INFO_EVENT(info);
63         if (GST_EVENT_TYPE(event) == GST_EVENT_FLUSH_STOP) {
64             AudioSourceProviderGStreamer* provider = reinterpret_cast<AudioSourceProviderGStreamer*>(userData);
65             provider->clearAdapters();
66         }
67     }
68     return GST_PAD_PROBE_OK;
69 }
70
71 static void copyGStreamerBuffersToAudioChannel(GstAdapter* adapter, AudioBus* bus , int channelNumber, size_t framesToProcess)
72 {
73     if (!gst_adapter_available(adapter)) {
74         bus->zero();
75         return;
76     }
77
78     size_t bytes = framesToProcess * sizeof(float);
79     if (gst_adapter_available(adapter) >= bytes) {
80         gst_adapter_copy(adapter, bus->channel(channelNumber)->mutableData(), 0, bytes);
81         gst_adapter_flush(adapter, bytes);
82     }
83 }
84
85 AudioSourceProviderGStreamer::AudioSourceProviderGStreamer()
86     : m_client(nullptr)
87     , m_deinterleaveSourcePads(0)
88     , m_deinterleavePadAddedHandlerId(0)
89     , m_deinterleaveNoMorePadsHandlerId(0)
90     , m_deinterleavePadRemovedHandlerId(0)
91 {
92     g_mutex_init(&m_adapterMutex);
93     m_frontLeftAdapter = gst_adapter_new();
94     m_frontRightAdapter = gst_adapter_new();
95 }
96
97 AudioSourceProviderGStreamer::~AudioSourceProviderGStreamer()
98 {
99     GRefPtr<GstElement> deinterleave = adoptGRef(gst_bin_get_by_name(GST_BIN(m_audioSinkBin.get()), "deinterleave"));
100     if (deinterleave) {
101         g_signal_handler_disconnect(deinterleave.get(), m_deinterleavePadAddedHandlerId);
102         g_signal_handler_disconnect(deinterleave.get(), m_deinterleaveNoMorePadsHandlerId);
103         g_signal_handler_disconnect(deinterleave.get(), m_deinterleavePadRemovedHandlerId);
104     }
105
106     g_object_unref(m_frontLeftAdapter);
107     g_object_unref(m_frontRightAdapter);
108     g_mutex_clear(&m_adapterMutex);
109 }
110
111 void AudioSourceProviderGStreamer::configureAudioBin(GstElement* audioBin, GstElement* teePredecessor)
112 {
113     m_audioSinkBin = audioBin;
114
115     GstElement* audioTee = gst_element_factory_make("tee", "audioTee");
116     GstElement* audioQueue = gst_element_factory_make("queue", nullptr);
117     GstElement* audioConvert = gst_element_factory_make("audioconvert", nullptr);
118     GstElement* audioConvert2 = gst_element_factory_make("audioconvert", nullptr);
119     GstElement* audioResample = gst_element_factory_make("audioresample", nullptr);
120     GstElement* audioResample2 = gst_element_factory_make("audioresample", nullptr);
121     GstElement* volumeElement = gst_element_factory_make("volume", "volume");
122     GstElement* audioSink = gst_element_factory_make("autoaudiosink", nullptr);
123
124     gst_bin_add_many(GST_BIN(m_audioSinkBin.get()), audioTee, audioQueue, audioConvert, audioResample, volumeElement, audioConvert2, audioResample2, audioSink, nullptr);
125
126     // In cases where the audio-sink needs elements before tee (such
127     // as scaletempo) they need to be linked to tee which in this case
128     // doesn't need a ghost pad. It is assumed that the teePredecessor
129     // chain already configured a ghost pad.
130     if (teePredecessor)
131         gst_element_link_pads_full(teePredecessor, "src", audioTee, "sink", GST_PAD_LINK_CHECK_NOTHING);
132     else {
133         // Add a ghostpad to the bin so it can proxy to tee.
134         GRefPtr<GstPad> audioTeeSinkPad = adoptGRef(gst_element_get_static_pad(audioTee, "sink"));
135         gst_element_add_pad(m_audioSinkBin.get(), gst_ghost_pad_new("sink", audioTeeSinkPad.get()));
136     }
137
138     // Link a new src pad from tee to queue ! audioconvert !
139     // audioresample ! volume ! audioconvert ! audioresample !
140     // autoaudiosink. The audioresample and audioconvert are needed to
141     // ensure the audio sink receives buffers in the correct format.
142     gst_element_link_pads_full(audioTee, "src_%u", audioQueue, "sink", GST_PAD_LINK_CHECK_NOTHING);
143     gst_element_link_pads_full(audioQueue, "src", audioConvert, "sink", GST_PAD_LINK_CHECK_NOTHING);
144     gst_element_link_pads_full(audioConvert, "src", audioResample, "sink", GST_PAD_LINK_CHECK_NOTHING);
145     gst_element_link_pads_full(audioResample, "src", volumeElement, "sink", GST_PAD_LINK_CHECK_NOTHING);
146     gst_element_link_pads_full(volumeElement, "src", audioConvert2, "sink", GST_PAD_LINK_CHECK_NOTHING);
147     gst_element_link_pads_full(audioConvert2, "src", audioResample2, "sink", GST_PAD_LINK_CHECK_NOTHING);
148     gst_element_link_pads_full(audioResample2, "src", audioSink, "sink", GST_PAD_LINK_CHECK_NOTHING);
149 }
150
151 void AudioSourceProviderGStreamer::provideInput(AudioBus* bus, size_t framesToProcess)
152 {
153     WTF::GMutexLocker<GMutex> lock(m_adapterMutex);
154     copyGStreamerBuffersToAudioChannel(m_frontLeftAdapter, bus, 0, framesToProcess);
155     copyGStreamerBuffersToAudioChannel(m_frontRightAdapter, bus, 1, framesToProcess);
156 }
157
158 GstFlowReturn AudioSourceProviderGStreamer::handleAudioBuffer(GstAppSink* sink)
159 {
160     if (!m_client)
161         return GST_FLOW_OK;
162
163     // Pull a buffer from appsink and store it the appropriate buffer
164     // list for the audio channel it represents.
165     GRefPtr<GstSample> sample = adoptGRef(gst_app_sink_pull_sample(sink));
166     if (!sample)
167         return gst_app_sink_is_eos(sink) ? GST_FLOW_EOS : GST_FLOW_ERROR;
168
169     GstBuffer* buffer = gst_sample_get_buffer(sample.get());
170     if (!buffer)
171         return GST_FLOW_ERROR;
172
173     GstCaps* caps = gst_sample_get_caps(sample.get());
174     if (!caps)
175         return GST_FLOW_ERROR;
176
177     GstAudioInfo info;
178     gst_audio_info_from_caps(&info, caps);
179
180     WTF::GMutexLocker<GMutex> lock(m_adapterMutex);
181
182     // Check the first audio channel. The buffer is supposed to store
183     // data of a single channel anyway.
184     switch (GST_AUDIO_INFO_POSITION(&info, 0)) {
185     case GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT:
186     case GST_AUDIO_CHANNEL_POSITION_MONO:
187         gst_adapter_push(m_frontLeftAdapter, gst_buffer_ref(buffer));
188         break;
189     case GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT:
190         gst_adapter_push(m_frontRightAdapter, gst_buffer_ref(buffer));
191         break;
192     default:
193         break;
194     }
195
196     return GST_FLOW_OK;
197 }
198
199 void AudioSourceProviderGStreamer::setClient(AudioSourceProviderClient* client)
200 {
201     ASSERT(client);
202     m_client = client;
203
204     // The volume element is used to mute audio playback towards the
205     // autoaudiosink. This is needed to avoid double playback of audio
206     // from our audio sink and from the WebAudio AudioDestination node
207     // supposedly configured already by application side.
208     GRefPtr<GstElement> volumeElement = adoptGRef(gst_bin_get_by_name(GST_BIN(m_audioSinkBin.get()), "volume"));
209     g_object_set(volumeElement.get(), "mute", TRUE, nullptr);
210
211     // The audioconvert and audioresample elements are needed to
212     // ensure deinterleave and the sinks downstream receive buffers in
213     // the format specified by the capsfilter.
214     GstElement* audioQueue = gst_element_factory_make("queue", nullptr);
215     GstElement* audioConvert  = gst_element_factory_make("audioconvert", nullptr);
216     GstElement* audioResample = gst_element_factory_make("audioresample", nullptr);
217     GstElement* capsFilter = gst_element_factory_make("capsfilter", nullptr);
218     GstElement* deInterleave = gst_element_factory_make("deinterleave", "deinterleave");
219
220     g_object_set(deInterleave, "keep-positions", TRUE, nullptr);
221     m_deinterleavePadAddedHandlerId = g_signal_connect(deInterleave, "pad-added", G_CALLBACK(onGStreamerDeinterleavePadAddedCallback), this);
222     m_deinterleaveNoMorePadsHandlerId = g_signal_connect(deInterleave, "no-more-pads", G_CALLBACK(onGStreamerDeinterleaveReadyCallback), this);
223     m_deinterleavePadRemovedHandlerId = g_signal_connect(deInterleave, "pad-removed", G_CALLBACK(onGStreamerDeinterleavePadRemovedCallback), this);
224
225     GstCaps* caps = gst_caps_new_simple("audio/x-raw", "rate", G_TYPE_INT, static_cast<int>(gSampleBitRate),
226         "channels", G_TYPE_INT, gNumberOfChannels,
227         "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
228         "layout", G_TYPE_STRING, "interleaved", nullptr);
229
230     g_object_set(capsFilter, "caps", caps, nullptr);
231     gst_caps_unref(caps);
232
233     gst_bin_add_many(GST_BIN(m_audioSinkBin.get()), audioQueue, audioConvert, audioResample, capsFilter, deInterleave, nullptr);
234
235     GRefPtr<GstElement> audioTee = adoptGRef(gst_bin_get_by_name(GST_BIN(m_audioSinkBin.get()), "audioTee"));
236
237     // Link a new src pad from tee to queue ! audioconvert !
238     // audioresample ! capsfilter ! deinterleave. Later
239     // on each deinterleaved planar audio channel will be routed to an
240     // appsink for data extraction and processing.
241     gst_element_link_pads_full(audioTee.get(), "src_%u", audioQueue, "sink", GST_PAD_LINK_CHECK_NOTHING);
242     gst_element_link_pads_full(audioQueue, "src", audioConvert, "sink", GST_PAD_LINK_CHECK_NOTHING);
243     gst_element_link_pads_full(audioConvert, "src", audioResample, "sink", GST_PAD_LINK_CHECK_NOTHING);
244     gst_element_link_pads_full(audioResample, "src", capsFilter, "sink", GST_PAD_LINK_CHECK_NOTHING);
245     gst_element_link_pads_full(capsFilter, "src", deInterleave, "sink", GST_PAD_LINK_CHECK_NOTHING);
246
247     gst_element_sync_state_with_parent(audioQueue);
248     gst_element_sync_state_with_parent(audioConvert);
249     gst_element_sync_state_with_parent(audioResample);
250     gst_element_sync_state_with_parent(capsFilter);
251     gst_element_sync_state_with_parent(deInterleave);
252 }
253
254 void AudioSourceProviderGStreamer::handleNewDeinterleavePad(GstPad* pad)
255 {
256     m_deinterleaveSourcePads++;
257
258     if (m_deinterleaveSourcePads > 2) {
259         g_warning("The AudioSourceProvider supports only mono and stereo audio. Silencing out this new channel.");
260         GstElement* queue = gst_element_factory_make("queue", nullptr);
261         GstElement* sink = gst_element_factory_make("fakesink", nullptr);
262         g_object_set(sink, "async", FALSE, nullptr);
263         gst_bin_add_many(GST_BIN(m_audioSinkBin.get()), queue, sink, nullptr);
264
265         GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(queue, "sink"));
266         gst_pad_link_full(pad, sinkPad.get(), GST_PAD_LINK_CHECK_NOTHING);
267
268         GQuark quark = g_quark_from_static_string("peer");
269         g_object_set_qdata(G_OBJECT(pad), quark, sinkPad.get());
270         gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING);
271         gst_element_sync_state_with_parent(queue);
272         gst_element_sync_state_with_parent(sink);
273         return;
274     }
275
276     // A new pad for a planar channel was added in deinterleave. Plug
277     // in an appsink so we can pull the data from each
278     // channel. Pipeline looks like:
279     // ... deinterleave ! queue ! appsink.
280     GstElement* queue = gst_element_factory_make("queue", nullptr);
281     GstElement* sink = gst_element_factory_make("appsink", nullptr);
282
283     GstAppSinkCallbacks callbacks;
284     callbacks.eos = nullptr;
285     callbacks.new_preroll = nullptr;
286     callbacks.new_sample = onAppsinkNewBufferCallback;
287     gst_app_sink_set_callbacks(GST_APP_SINK(sink), &callbacks, this, nullptr);
288
289     g_object_set(sink, "async", FALSE, nullptr);
290
291     GRefPtr<GstCaps> caps = adoptGRef(gst_caps_new_simple("audio/x-raw", "rate", G_TYPE_INT, static_cast<int>(gSampleBitRate),
292         "channels", G_TYPE_INT, 1,
293         "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
294         "layout", G_TYPE_STRING, "interleaved", nullptr));
295
296     gst_app_sink_set_caps(GST_APP_SINK(sink), caps.get());
297
298     gst_bin_add_many(GST_BIN(m_audioSinkBin.get()), queue, sink, nullptr);
299
300     GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(queue, "sink"));
301     gst_pad_link_full(pad, sinkPad.get(), GST_PAD_LINK_CHECK_NOTHING);
302
303     GQuark quark = g_quark_from_static_string("peer");
304     g_object_set_qdata(G_OBJECT(pad), quark, sinkPad.get());
305
306     gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING);
307
308     sinkPad = adoptGRef(gst_element_get_static_pad(sink, "sink"));
309     gst_pad_add_probe(sinkPad.get(), GST_PAD_PROBE_TYPE_EVENT_FLUSH, onAppsinkFlushCallback, this, nullptr);
310
311     gst_element_sync_state_with_parent(queue);
312     gst_element_sync_state_with_parent(sink);
313 }
314
315 void AudioSourceProviderGStreamer::handleRemovedDeinterleavePad(GstPad* pad)
316 {
317     m_deinterleaveSourcePads--;
318
319     // Remove the queue ! appsink chain downstream of deinterleave.
320     GQuark quark = g_quark_from_static_string("peer");
321     GstPad* sinkPad = reinterpret_cast<GstPad*>(g_object_get_qdata(G_OBJECT(pad), quark));
322     GRefPtr<GstElement> queue = adoptGRef(gst_pad_get_parent_element(sinkPad));
323     GRefPtr<GstPad> queueSrcPad = adoptGRef(gst_element_get_static_pad(queue.get(), "src"));
324     GRefPtr<GstPad> appsinkSinkPad = adoptGRef(gst_pad_get_peer(queueSrcPad.get()));
325     GRefPtr<GstElement> sink = adoptGRef(gst_pad_get_parent_element(appsinkSinkPad.get()));
326     gst_element_set_state(sink.get(), GST_STATE_NULL);
327     gst_element_set_state(queue.get(), GST_STATE_NULL);
328     gst_element_unlink(queue.get(), sink.get());
329     gst_bin_remove_many(GST_BIN(m_audioSinkBin.get()), queue.get(), sink.get(), nullptr);
330 }
331
332 void AudioSourceProviderGStreamer::deinterleavePadsConfigured()
333 {
334     ASSERT(m_client);
335     ASSERT(m_deinterleaveSourcePads == gNumberOfChannels);
336
337     m_client->setFormat(m_deinterleaveSourcePads, gSampleBitRate);
338 }
339
340 void AudioSourceProviderGStreamer::clearAdapters()
341 {
342     WTF::GMutexLocker<GMutex> lock(m_adapterMutex);
343     gst_adapter_clear(m_frontLeftAdapter);
344     gst_adapter_clear(m_frontRightAdapter);
345 }
346
347 } // WebCore
348
349 #endif // ENABLE(WEB_AUDIO) && ENABLE(VIDEO) && USE(GSTREAMER)