8ab401703460191edce523c8affa5c65b6c12648
[harmattan/cameraplus] / declarative / videoplayer.cpp
1 /*!
2  * This file is part of CameraPlus.
3  *
4  * Copyright (C) 2012-2013 Mohammed Sameer <msameer@foolab.org>
5  *
6  * This library 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  * This library 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 this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20
21 #include "videoplayer.h"
22 #if defined(QT4)
23 #include <QDeclarativeInfo>
24 #elif defined(QT5)
25 #include <QQmlInfo>
26 #endif
27 #include "cameraconfig.h"
28 #include <QTimer>
29 #include "qtcamviewfinderrenderer.h"
30 #include <QPainter>
31 #include <QMatrix4x4>
32 #include <cmath>
33
34 #if defined(QT4)
35 VideoPlayer::VideoPlayer(QDeclarativeItem *parent) :
36   QDeclarativeItem(parent),
37 #elif defined(QT5)
38 VideoPlayer::VideoPlayer(QQuickItem *parent) :
39   QQuickPaintedItem(parent),
40 #endif
41   m_config(0),
42   m_renderer(0),
43   m_bin(0),
44   m_state(VideoPlayer::StateStopped),
45   m_timer(new QTimer(this)),
46   m_pos(0) {
47
48   m_timer->setSingleShot(false);
49   m_timer->setInterval(500);
50   QObject::connect(m_timer, SIGNAL(timeout()), this, SIGNAL(positionChanged()));
51
52 #if defined(QT4)
53   setFlag(QGraphicsItem::ItemHasNoContents, false);
54 #endif
55
56 #if defined(QT5)
57   setRenderTarget(QQuickPaintedItem::FramebufferObject);
58   setSmooth(false);
59   setAntialiasing(false);
60 #endif
61 }
62
63 VideoPlayer::~VideoPlayer() {
64   stop();
65
66   if (m_bin) {
67     gst_object_unref(m_bin);
68     m_bin = 0;
69   }
70 }
71
72 void VideoPlayer::componentComplete() {
73 #if defined(QT4)
74   QDeclarativeItem::componentComplete();
75 #elif defined(QT5)
76   QQuickPaintedItem::componentComplete();
77 #endif
78
79   if (!m_config) {
80     qmlInfo(this) << "CameraConfig not set";
81     return;
82   }
83
84   m_renderer = QtCamViewfinderRenderer::create(m_config->config(), this);
85   if (!m_renderer) {
86     qmlInfo(this) << "Failed to create viewfinder renderer";
87     return;
88   }
89
90   m_renderer->resize(QSizeF(width(), height()));
91   QObject::connect(m_renderer, SIGNAL(updateRequested()), this, SLOT(updateRequested()));
92
93   if (m_bin) {
94     g_object_set(m_bin, "video-sink", m_renderer->sinkElement(), NULL);
95   }
96 }
97
98 void VideoPlayer::classBegin() {
99 #if defined(QT4)
100   QDeclarativeItem::classBegin();
101 #elif defined(QT5)
102   QQuickPaintedItem::classBegin();
103 #endif
104
105   m_bin = gst_element_factory_make ("playbin2", "VideoPlayerBin");
106   if (!m_bin) {
107     qmlInfo(this) << "Failed to create playbin2";
108     return;
109   }
110
111   g_signal_connect (G_OBJECT (m_bin), "notify::volume", G_CALLBACK (on_volume_changed), this);
112   g_object_set (m_bin, "flags", 99, NULL);
113
114   GstElement *elem = gst_element_factory_make("pulsesink", "VideoPlayerPulseSink");
115   if (!elem) {
116     qmlInfo(this) << "Failed to create pulsesink";
117   }
118   else {
119     g_object_set (m_bin, "audio-sink", elem, NULL);
120   }
121
122   GstBus *bus = gst_element_get_bus(m_bin);
123   gst_bus_add_watch(bus, bus_call, this);
124   gst_object_unref(bus);
125 }
126
127 QUrl VideoPlayer::source() const {
128   return m_url;
129 }
130
131 void VideoPlayer::setSource(const QUrl& source) {
132   if (m_url != source) {
133     m_url = source;
134     emit sourceChanged();
135   }
136 }
137
138 CameraConfig *VideoPlayer::cameraConfig() const {
139   return m_config;  
140 }
141
142 void VideoPlayer::setCameraConfig(CameraConfig *config) {
143   if (m_config && m_config != config) {
144     qmlInfo(this) << "Cannot reset CameraConfig";
145     return;
146   }
147
148   if (!config) {
149     qmlInfo(this) << "CameraConfig cannot be empty";
150     return;
151   }
152
153   if (m_config != config) {
154     m_config = config;
155     emit cameraConfigChanged();
156   }
157 }
158
159 qint64 VideoPlayer::duration() const {
160   if (!m_bin) {
161     return 0;
162   }
163
164   GstFormat format = GST_FORMAT_TIME;
165   qint64 dur = 0;
166   if (!gst_element_query_duration(m_bin, &format, &dur)) {
167     qmlInfo(this) << "Failed to query pipeline duration";
168     return 0;
169   }
170
171   if (format != GST_FORMAT_TIME) {
172     qmlInfo(this) << "Pipeline format is not time";
173     return 0;
174   }
175
176   dur /= 1000000;
177
178   return dur;
179 }
180
181 qint64 VideoPlayer::position() {
182   if (!m_bin) {
183     return 0;
184   }
185
186   GstFormat format = GST_FORMAT_TIME;
187   qint64 pos = 0;
188   if (!gst_element_query_position(m_bin, &format, &pos)) {
189     qmlInfo(this) << "Failed to query pipeline position";
190     return m_pos;
191   }
192
193   if (format != GST_FORMAT_TIME) {
194     qmlInfo(this) << "Pipeline format is not time";
195     return m_pos;
196   }
197
198   pos /= 1000000;
199
200   m_pos = pos;
201
202   return pos;
203 }
204
205 void VideoPlayer::setPosition(qint64 position) {
206   seek(position);
207 }
208
209 bool VideoPlayer::pause() {
210   return setState(VideoPlayer::StatePaused);
211 }
212
213 bool VideoPlayer::play() {
214   return setState(VideoPlayer::StatePlaying);
215 }
216
217 bool VideoPlayer::seek(qint64 offset) {
218   if (!m_bin) {
219     qmlInfo(this) << "no playbin2";
220     return false;
221   }
222
223   qint64 pos = offset;
224
225   offset *= 1000000;
226
227   GstSeekFlags flags = (GstSeekFlags)(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE);
228   gboolean ret = gst_element_seek_simple (m_bin, GST_FORMAT_TIME,
229                                           flags, offset);
230
231   if (ret) {
232     m_pos = pos;
233
234     return TRUE;
235   }
236
237   return FALSE;
238 }
239
240 bool VideoPlayer::stop() {
241   return setState(VideoPlayer::StateStopped);
242 }
243
244 void VideoPlayer::geometryChanged(const QRectF& newGeometry, const QRectF& oldGeometry) {
245 #if defined(QT4)
246   QDeclarativeItem::geometryChanged(newGeometry, oldGeometry);
247 #elif defined(QT5)
248   QQuickPaintedItem::geometryChanged(newGeometry, oldGeometry);
249 #endif
250
251   if (m_renderer) {
252     m_renderer->resize(newGeometry.size());
253   }
254 }
255
256 #if defined(QT4)
257 void VideoPlayer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
258                        QWidget *widget) {
259
260   Q_UNUSED(widget);
261   Q_UNUSED(option);
262
263   painter->fillRect(boundingRect(), Qt::black);
264
265 #elif defined(QT5)
266 void VideoPlayer::paint(QPainter *painter) {
267   painter->fillRect(contentsBoundingRect(), Qt::black);
268
269 #endif
270
271   if (!m_renderer) {
272     return;
273   }
274
275   bool needsNativePainting = m_renderer->needsNativePainting();
276
277   if (needsNativePainting) {
278     painter->beginNativePainting();
279   }
280
281   m_renderer->paint(QMatrix4x4(painter->combinedTransform()), painter->viewport());
282
283   if (needsNativePainting) {
284     painter->endNativePainting();
285   }
286 }
287
288 VideoPlayer::State VideoPlayer::state() const {
289   return m_state;
290 }
291
292 bool VideoPlayer::setState(const VideoPlayer::State& state) {
293   if (state == m_state) {
294     return true;
295   }
296
297   if (!m_bin) {
298     qmlInfo(this) << "no playbin2";
299     return false;
300   }
301
302   if (state == VideoPlayer::StatePaused) {
303     m_timer->stop();
304
305     // Set uri if needed:
306     if (m_state == VideoPlayer::StateStopped) {
307       const char *uri = m_url.toString().toUtf8().constData();
308       g_object_set(m_bin, "uri", uri, NULL);
309     }
310
311     if (gst_element_set_state(m_bin, GST_STATE_PAUSED) == GST_STATE_CHANGE_FAILURE) {
312       qmlInfo(this) << "error setting pipeline to PAUSED";
313       return false;
314     }
315
316     GstState st;
317     if (gst_element_get_state(m_bin, &st, NULL, GST_CLOCK_TIME_NONE)
318         == GST_STATE_CHANGE_FAILURE) {
319       qmlInfo(this) << "setting pipeline to PAUSED failed";
320       return false;
321     }
322
323     if (st != GST_STATE_PAUSED) {
324       qmlInfo(this) << "pipeline failed to transition to to PAUSED state";
325       return false;
326     }
327
328     m_state = state;
329     emit stateChanged();
330
331     return true;
332   }
333   else if (state == VideoPlayer::StatePlaying) {
334     // Set uri if needed:
335     if (m_state == VideoPlayer::StateStopped) {
336       const char *uri = m_url.toString().toUtf8().constData();
337       g_object_set(m_bin, "uri", uri, NULL);
338     }
339
340     if (gst_element_set_state(m_bin, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
341       qmlInfo(this) << "error setting pipeline to PLAYING";
342       return false;
343     }
344
345     GstState st;
346     if (gst_element_get_state(m_bin, &st, NULL, GST_CLOCK_TIME_NONE)
347         == GST_STATE_CHANGE_FAILURE) {
348       qmlInfo(this) << "setting pipeline to PLAYING failed";
349       return false;
350     }
351
352     if (st != GST_STATE_PLAYING) {
353       qmlInfo(this) << "pipeline failed to transition to to PLAYING state";
354       return false;
355     }
356
357     m_state = state;
358     emit stateChanged();
359
360     emit durationChanged();
361     emit positionChanged();
362
363     m_timer->start();
364     return true;
365   }
366   else {
367     m_timer->stop();
368     m_pos = 0;
369
370     if (gst_element_set_state(m_bin, GST_STATE_NULL) == GST_STATE_CHANGE_FAILURE) {
371       qmlInfo(this) << "error setting pipeline to NULL";
372       return false;
373     }
374
375     GstState st;
376     if (gst_element_get_state(m_bin, &st, NULL, GST_CLOCK_TIME_NONE)
377         == GST_STATE_CHANGE_FAILURE) {
378       qmlInfo(this) << "setting pipeline to NULL failed";
379       return false;
380     }
381
382     if (st != GST_STATE_NULL) {
383       qmlInfo(this) << "pipeline failed to transition to to NULL state";
384       return false;
385     }
386
387     m_state = state;
388     emit stateChanged();
389
390     emit durationChanged();
391     emit positionChanged();
392
393     return true;
394   }
395 }
396
397 gboolean VideoPlayer::bus_call(GstBus *bus, GstMessage *msg, gpointer data) {
398   Q_UNUSED(bus);
399
400   VideoPlayer *that = (VideoPlayer *) data;
401
402   gchar *debug = NULL;
403   GError *err = NULL;
404
405   switch (GST_MESSAGE_TYPE(msg)) {
406   case GST_MESSAGE_EOS:
407     that->stop();
408     break;
409
410   case GST_MESSAGE_ERROR:
411     gst_message_parse_error (msg, &err, &debug);
412
413     emit that->error(err->message, err->code, debug);
414     that->stop();
415     if (err) {
416       g_error_free (err);
417     }
418
419     if (debug) {
420       g_free (debug);
421     }
422
423     break;
424
425   default:
426     break;
427   }
428
429   return TRUE;  
430 }
431
432 void VideoPlayer::updateRequested() {
433   update();
434 }
435
436 quint32 VideoPlayer::volume() {
437   double vol = 1.0;
438   g_object_get (m_bin, "volume", &vol, NULL);
439
440   qint32 res = (int)round(vol * 100.0);
441
442   return res;
443 }
444
445 void VideoPlayer::setVolume(quint32 volume) {
446   if (VideoPlayer::volume() != volume) {
447     double vol = volume / 100.0;
448     g_object_set (m_bin, "volume", vol, NULL);
449     emit volumeChanged();
450   }
451 }
452
453 void VideoPlayer::on_volume_changed(GObject *object, GParamSpec *pspec, gpointer user_data) {
454   Q_UNUSED(object);
455   Q_UNUSED(pspec);
456
457   VideoPlayer *player = (VideoPlayer *) user_data;
458
459   QMetaObject::invokeMethod(player, "volumeChanged", Qt::QueuedConnection);
460 }