9129498160f1be3e6cfe7f04764b4d79d48f8f3f
[WebKit-https.git] / Source / WebCore / platform / audio / gstreamer / AudioFileReaderGStreamer.cpp
1 /*
2  *  Copyright (C) 2011, 2012 Igalia S.L
3  *  Copyright (C) 2011 Zan Dobersek  <zandobersek@gmail.com>
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19
20 #include "config.h"
21
22 #if ENABLE(WEB_AUDIO)
23
24 #include "AudioFileReader.h"
25 #include "AudioBus.h"
26 #include "GRefPtrGStreamer.h"
27 #include <gio/gio.h>
28 #include <gst/app/gstappsink.h>
29 #include <gst/audio/audio-info.h>
30 #include <gst/gst.h>
31 #include <wtf/MainThread.h>
32 #include <wtf/Noncopyable.h>
33 #include <wtf/RunLoop.h>
34 #include <wtf/Threading.h>
35 #include <wtf/WeakPtr.h>
36 #include <wtf/glib/GRefPtr.h>
37 #include <wtf/glib/GUniquePtr.h>
38
39 namespace WebCore {
40
41 class AudioFileReader {
42     WTF_MAKE_NONCOPYABLE(AudioFileReader);
43 public:
44     AudioFileReader(const char* filePath);
45     AudioFileReader(const void* data, size_t dataSize);
46     ~AudioFileReader();
47
48     PassRefPtr<AudioBus> createBus(float sampleRate, bool mixToMono);
49
50 private:
51     WeakPtr<AudioFileReader> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
52
53     static void deinterleavePadAddedCallback(AudioFileReader*, GstPad*);
54     static void deinterleaveReadyCallback(AudioFileReader*);
55     static void decodebinPadAddedCallback(AudioFileReader*, GstPad*);
56
57     void handleMessage(GstMessage*);
58     void handleNewDeinterleavePad(GstPad*);
59     void deinterleavePadsConfigured();
60     void plugDeinterleave(GstPad*);
61     void decodeAudioForBusCreation();
62     GstFlowReturn handleSample(GstAppSink*);
63
64     WeakPtrFactory<AudioFileReader> m_weakPtrFactory;
65     RunLoop& m_runLoop;
66     const void* m_data { nullptr };
67     size_t m_dataSize { 0 };
68     const char* m_filePath { nullptr };
69
70     float m_sampleRate { 0 };
71     int m_channels { 0 };
72     GRefPtr<GstBufferList> m_frontLeftBuffers;
73     GRefPtr<GstBufferList> m_frontRightBuffers;
74
75     GRefPtr<GstElement> m_pipeline;
76     unsigned m_channelSize { 0 };
77     GRefPtr<GstElement> m_decodebin;
78     GRefPtr<GstElement> m_deInterleave;
79     bool m_errorOccurred { false };
80 };
81
82 static void copyGstreamerBuffersToAudioChannel(GstBufferList* buffers, AudioChannel* audioChannel)
83 {
84     float* destination = audioChannel->mutableData();
85     unsigned bufferCount = gst_buffer_list_length(buffers);
86     for (unsigned i = 0; i < bufferCount; ++i) {
87         GstBuffer* buffer = gst_buffer_list_get(buffers, i);
88         ASSERT(buffer);
89         gsize bufferSize = gst_buffer_get_size(buffer);
90         gst_buffer_extract(buffer, 0, destination, bufferSize);
91         destination += bufferSize / sizeof(float);
92     }
93 }
94
95 void AudioFileReader::deinterleavePadAddedCallback(AudioFileReader* reader, GstPad* pad)
96 {
97     reader->handleNewDeinterleavePad(pad);
98 }
99
100 void AudioFileReader::deinterleaveReadyCallback(AudioFileReader* reader)
101 {
102     reader->deinterleavePadsConfigured();
103 }
104
105 void AudioFileReader::decodebinPadAddedCallback(AudioFileReader* reader, GstPad* pad)
106 {
107     reader->plugDeinterleave(pad);
108 }
109
110 AudioFileReader::AudioFileReader(const char* filePath)
111     : m_weakPtrFactory(this)
112     , m_runLoop(RunLoop::current())
113     , m_filePath(filePath)
114 {
115 }
116
117 AudioFileReader::AudioFileReader(const void* data, size_t dataSize)
118     : m_weakPtrFactory(this)
119     , m_runLoop(RunLoop::current())
120     , m_data(data)
121     , m_dataSize(dataSize)
122 {
123 }
124
125 AudioFileReader::~AudioFileReader()
126 {
127     if (m_pipeline) {
128         GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline.get())));
129         ASSERT(bus);
130         gst_bus_set_sync_handler(bus.get(), nullptr, nullptr, nullptr);
131
132         gst_element_set_state(m_pipeline.get(), GST_STATE_NULL);
133         m_pipeline = nullptr;
134     }
135
136     if (m_decodebin) {
137         g_signal_handlers_disconnect_matched(m_decodebin.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
138         m_decodebin = nullptr;
139     }
140
141     if (m_deInterleave) {
142         g_signal_handlers_disconnect_matched(m_deInterleave.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
143         m_deInterleave = nullptr;
144     }
145 }
146
147 GstFlowReturn AudioFileReader::handleSample(GstAppSink* sink)
148 {
149     GRefPtr<GstSample> sample = adoptGRef(gst_app_sink_pull_sample(sink));
150     if (!sample)
151         return GST_FLOW_ERROR;
152
153     GstBuffer* buffer = gst_sample_get_buffer(sample.get());
154     if (!buffer)
155         return GST_FLOW_ERROR;
156
157     GstCaps* caps = gst_sample_get_caps(sample.get());
158     if (!caps)
159         return GST_FLOW_ERROR;
160
161     GstAudioInfo info;
162     gst_audio_info_from_caps(&info, caps);
163     int frames = gst_buffer_get_size(buffer) / info.bpf;
164
165     // Check the first audio channel. The buffer is supposed to store
166     // data of a single channel anyway.
167     switch (GST_AUDIO_INFO_POSITION(&info, 0)) {
168     case GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT:
169     case GST_AUDIO_CHANNEL_POSITION_MONO:
170         gst_buffer_list_add(m_frontLeftBuffers.get(), gst_buffer_ref(buffer));
171         m_channelSize += frames;
172         break;
173     case GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT:
174         gst_buffer_list_add(m_frontRightBuffers.get(), gst_buffer_ref(buffer));
175         break;
176     default:
177         break;
178     }
179
180     return GST_FLOW_OK;
181 }
182
183 void AudioFileReader::handleMessage(GstMessage* message)
184 {
185     ASSERT(&m_runLoop == &RunLoop::current());
186
187     GUniqueOutPtr<GError> error;
188     GUniqueOutPtr<gchar> debug;
189
190     switch (GST_MESSAGE_TYPE(message)) {
191     case GST_MESSAGE_EOS:
192         m_runLoop.stop();
193         break;
194     case GST_MESSAGE_WARNING:
195         gst_message_parse_warning(message, &error.outPtr(), &debug.outPtr());
196         g_warning("Warning: %d, %s. Debug output: %s", error->code,  error->message, debug.get());
197         break;
198     case GST_MESSAGE_ERROR:
199         gst_message_parse_error(message, &error.outPtr(), &debug.outPtr());
200         g_warning("Error: %d, %s. Debug output: %s", error->code,  error->message, debug.get());
201         m_errorOccurred = true;
202         gst_element_set_state(m_pipeline.get(), GST_STATE_NULL);
203         m_runLoop.stop();
204         break;
205     default:
206         break;
207     }
208 }
209
210 void AudioFileReader::handleNewDeinterleavePad(GstPad* pad)
211 {
212     // A new pad for a planar channel was added in deinterleave. Plug
213     // in an appsink so we can pull the data from each
214     // channel. Pipeline looks like:
215     // ... deinterleave ! queue ! appsink.
216     GstElement* queue = gst_element_factory_make("queue", 0);
217     GstElement* sink = gst_element_factory_make("appsink", 0);
218
219     static GstAppSinkCallbacks callbacks = {
220         nullptr, // eos
221         nullptr, // new_preroll
222         // new_sample
223         [](GstAppSink* sink, gpointer userData) -> GstFlowReturn {
224             return static_cast<AudioFileReader*>(userData)->handleSample(sink);
225         },
226         { nullptr }
227     };
228     gst_app_sink_set_callbacks(GST_APP_SINK(sink), &callbacks, this, 0);
229
230     g_object_set(sink, "sync", FALSE, NULL);
231
232     gst_bin_add_many(GST_BIN(m_pipeline.get()), queue, sink, nullptr);
233
234     GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(queue, "sink"));
235     gst_pad_link_full(pad, sinkPad.get(), GST_PAD_LINK_CHECK_NOTHING);
236
237     gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING);
238
239     gst_element_sync_state_with_parent(queue);
240     gst_element_sync_state_with_parent(sink);
241 }
242
243 void AudioFileReader::deinterleavePadsConfigured()
244 {
245     // All deinterleave src pads are now available, let's roll to
246     // PLAYING so data flows towards the sinks and it can be retrieved.
247     gst_element_set_state(m_pipeline.get(), GST_STATE_PLAYING);
248 }
249
250 void AudioFileReader::plugDeinterleave(GstPad* pad)
251 {
252     // Ignore any additional source pads just in case.
253     if (m_deInterleave)
254         return;
255
256     // A decodebin pad was added, plug in a deinterleave element to
257     // separate each planar channel. Sub pipeline looks like
258     // ... decodebin2 ! audioconvert ! audioresample ! capsfilter ! deinterleave.
259     GstElement* audioConvert  = gst_element_factory_make("audioconvert", 0);
260     GstElement* audioResample = gst_element_factory_make("audioresample", 0);
261     GstElement* capsFilter = gst_element_factory_make("capsfilter", 0);
262     m_deInterleave = gst_element_factory_make("deinterleave", "deinterleave");
263
264     g_object_set(m_deInterleave.get(), "keep-positions", TRUE, NULL);
265     g_signal_connect_swapped(m_deInterleave.get(), "pad-added", G_CALLBACK(deinterleavePadAddedCallback), this);
266     g_signal_connect_swapped(m_deInterleave.get(), "no-more-pads", G_CALLBACK(deinterleaveReadyCallback), this);
267
268     GRefPtr<GstCaps> caps = adoptGRef(gst_caps_new_simple("audio/x-raw",
269         "rate", G_TYPE_INT, static_cast<int>(m_sampleRate),
270         "channels", G_TYPE_INT, m_channels,
271         "format", G_TYPE_STRING, GST_AUDIO_NE(F32),
272         "layout", G_TYPE_STRING, "interleaved", nullptr));
273     g_object_set(capsFilter, "caps", caps.get(), nullptr);
274
275     gst_bin_add_many(GST_BIN(m_pipeline.get()), audioConvert, audioResample, capsFilter, m_deInterleave.get(), nullptr);
276
277     GRefPtr<GstPad> sinkPad = adoptGRef(gst_element_get_static_pad(audioConvert, "sink"));
278     gst_pad_link_full(pad, sinkPad.get(), GST_PAD_LINK_CHECK_NOTHING);
279
280     gst_element_link_pads_full(audioConvert, "src", audioResample, "sink", GST_PAD_LINK_CHECK_NOTHING);
281     gst_element_link_pads_full(audioResample, "src", capsFilter, "sink", GST_PAD_LINK_CHECK_NOTHING);
282     gst_element_link_pads_full(capsFilter, "src", m_deInterleave.get(), "sink", GST_PAD_LINK_CHECK_NOTHING);
283
284     gst_element_sync_state_with_parent(audioConvert);
285     gst_element_sync_state_with_parent(audioResample);
286     gst_element_sync_state_with_parent(capsFilter);
287     gst_element_sync_state_with_parent(m_deInterleave.get());
288 }
289
290 void AudioFileReader::decodeAudioForBusCreation()
291 {
292     ASSERT(&m_runLoop == &RunLoop::current());
293
294     // Build the pipeline (giostreamsrc | filesrc) ! decodebin2
295     // A deinterleave element is added once a src pad becomes available in decodebin.
296     m_pipeline = gst_pipeline_new(nullptr);
297
298     GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline.get())));
299     ASSERT(bus);
300     gst_bus_set_sync_handler(bus.get(), [](GstBus*, GstMessage* message, gpointer userData) {
301         auto& reader = *static_cast<AudioFileReader*>(userData);
302         if (&reader.m_runLoop == &RunLoop::current())
303             reader.handleMessage(message);
304         else {
305             GRefPtr<GstMessage> protectMessage(message);
306             auto weakThis = reader.createWeakPtr();
307             reader.m_runLoop.dispatch([weakThis, protectMessage] {
308                 if (weakThis)
309                     weakThis->handleMessage(protectMessage.get());
310             });
311         }
312         gst_message_unref(message);
313         return GST_BUS_DROP;
314     }, this, nullptr);
315
316     GstElement* source;
317     if (m_data) {
318         ASSERT(m_dataSize);
319         source = gst_element_factory_make("giostreamsrc", 0);
320         GRefPtr<GInputStream> memoryStream = adoptGRef(g_memory_input_stream_new_from_data(m_data, m_dataSize, 0));
321         g_object_set(source, "stream", memoryStream.get(), NULL);
322     } else {
323         source = gst_element_factory_make("filesrc", 0);
324         g_object_set(source, "location", m_filePath, NULL);
325     }
326
327     m_decodebin = gst_element_factory_make("decodebin", "decodebin");
328     g_signal_connect_swapped(m_decodebin.get(), "pad-added", G_CALLBACK(decodebinPadAddedCallback), this);
329
330     gst_bin_add_many(GST_BIN(m_pipeline.get()), source, m_decodebin.get(), NULL);
331     gst_element_link_pads_full(source, "src", m_decodebin.get(), "sink", GST_PAD_LINK_CHECK_NOTHING);
332
333     // Catch errors here immediately, there might not be an error message if we're unlucky.
334     if (gst_element_set_state(m_pipeline.get(), GST_STATE_PAUSED) == GST_STATE_CHANGE_FAILURE) {
335         g_warning("Error: Failed to set pipeline to PAUSED");
336         m_errorOccurred = true;
337         m_runLoop.stop();
338     }
339 }
340
341 PassRefPtr<AudioBus> AudioFileReader::createBus(float sampleRate, bool mixToMono)
342 {
343     m_sampleRate = sampleRate;
344     m_channels = mixToMono ? 1 : 2;
345
346     m_frontLeftBuffers = adoptGRef(gst_buffer_list_new());
347     m_frontRightBuffers = adoptGRef(gst_buffer_list_new());
348
349     // Start the pipeline processing just after the loop is started.
350     m_runLoop.dispatch([this] { decodeAudioForBusCreation(); });
351     m_runLoop.run();
352
353     // Set pipeline to GST_STATE_NULL state here already ASAP to
354     // release any resources that might still be used.
355     gst_element_set_state(m_pipeline.get(), GST_STATE_NULL);
356
357     if (m_errorOccurred)
358         return nullptr;
359
360     RefPtr<AudioBus> audioBus = AudioBus::create(m_channels, m_channelSize, true);
361     audioBus->setSampleRate(m_sampleRate);
362
363     copyGstreamerBuffersToAudioChannel(m_frontLeftBuffers.get(), audioBus->channel(0));
364     if (!mixToMono)
365         copyGstreamerBuffersToAudioChannel(m_frontRightBuffers.get(), audioBus->channel(1));
366
367     return audioBus;
368 }
369
370 PassRefPtr<AudioBus> createBusFromAudioFile(const char* filePath, bool mixToMono, float sampleRate)
371 {
372     RefPtr<AudioBus> returnValue;
373     auto threadID = createThread("AudioFileReader", [&returnValue, filePath, mixToMono, sampleRate] {
374         returnValue = AudioFileReader(filePath).createBus(sampleRate, mixToMono);
375     });
376     waitForThreadCompletion(threadID);
377     return returnValue;
378 }
379
380 PassRefPtr<AudioBus> createBusFromInMemoryAudioFile(const void* data, size_t dataSize, bool mixToMono, float sampleRate)
381 {
382     RefPtr<AudioBus> returnValue;
383     auto threadID = createThread("AudioFileReader", [&returnValue, data, dataSize, mixToMono, sampleRate] {
384         returnValue = AudioFileReader(data, dataSize).createBus(sampleRate, mixToMono);
385     });
386     waitForThreadCompletion(threadID);
387     return returnValue;
388 }
389
390 } // WebCore
391
392 #endif // ENABLE(WEB_AUDIO)