Silence g++/moc warnings
[harmattan/cameraplus] / lib / qtcamviewfinderrenderermeego.cpp
1 /*!
2  * This file is part of CameraPlus.
3  *
4  * Copyright (C) 2012 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 "qtcamviewfinderrenderermeego.h"
22 #include <QDebug>
23 #include <gst/video/video.h>
24 #include <QPainter>
25 #include "qtcamconfig.h"
26 #include <QX11Info>
27 #include <QGLContext>
28 #include <EGL/egl.h>
29 #include <QGLShaderProgram>
30 #include <gst/interfaces/meegovideotexture.h>
31
32 QT_CAM_VIEWFINDER_RENDERER(RENDERER_TYPE_MEEGO, QtCamViewfinderRendererMeeGo);
33
34 #define GL_TEXTURE_EXTERNAL_OES                  0x8060
35
36 static const QString FRAGMENT_SHADER = ""
37     "#extension GL_OES_EGL_image_external: enable\n"
38     "uniform samplerExternalOES texture0;"
39     "varying lowp vec2 fragTexCoord;"
40     "void main() {"
41     "  gl_FragColor = texture2D(texture0, fragTexCoord);"
42     "}"
43   "";
44
45 static const QString VERTEX_SHADER = ""
46     "attribute highp vec4 inputVertex;"
47     "attribute lowp vec2 textureCoord;"
48     "uniform highp mat4 matrix;"
49     "uniform highp mat4 matrixWorld;"
50     "varying lowp vec2 fragTexCoord;"
51     ""
52     "void main() {"
53     "  gl_Position = matrix * matrixWorld * inputVertex;"
54     "  fragTexCoord = textureCoord;"
55     "}"
56   "";
57
58 QtCamViewfinderRendererMeeGo::QtCamViewfinderRendererMeeGo(QtCamConfig *config,
59                                                                QObject *parent) :
60   QtCamViewfinderRenderer(config, parent),
61   m_conf(config),
62   m_sink(0),
63   m_frame(-1),
64   m_id(0),
65   m_notify(0),
66   m_needsInit(true),
67   m_program(0) {
68
69   // Texture coordinates:
70   // Reversed because of Qt reversed coordinate system
71   m_texCoords[0] = 0;       m_texCoords[1] = 1;
72   m_texCoords[2] = 1;       m_texCoords[3] = 1;
73   m_texCoords[4] = 1;       m_texCoords[5] = 0;
74   m_texCoords[6] = 0;       m_texCoords[7] = 0;
75
76   bzero(&m_vertexCoords, 8);
77 }
78
79 QtCamViewfinderRendererMeeGo::~QtCamViewfinderRendererMeeGo() {
80   if (m_sink) {
81     g_signal_handler_disconnect(m_sink, m_id);
82     g_signal_handler_disconnect(m_sink, m_notify);
83     g_object_remove_toggle_ref(G_OBJECT(m_sink), (GToggleNotify)sink_notify, this);
84     m_sink = 0;
85   }
86 }
87
88 void QtCamViewfinderRendererMeeGo::paint(QPainter *painter) {
89   QMutexLocker locker(&m_frameMutex);
90   if (m_frame == -1) {
91     return;
92   }
93
94   painter->beginNativePainting();
95
96   if (m_needsInit) {
97     calculateProjectionMatrix(painter->viewport());
98     m_needsInit = false;
99   }
100
101   if (!m_program) {
102     // Program will be created if needed and will never be deleted even
103     // if attaching the shaders fail.
104     createProgram();
105   }
106
107   paintFrame(painter, m_frame);
108
109   painter->endNativePainting();
110 }
111
112 void QtCamViewfinderRendererMeeGo::resize(const QSizeF& size) {
113   if (size == m_size) {
114     return;
115   }
116
117   m_size = size;
118
119   m_renderArea = QRectF();
120
121   calculateCoords();
122
123   // TODO: this will destroy everything
124   // but we need a way to reset the viewport and the transformation matrix only.
125   m_needsInit = true;
126 }
127
128 void QtCamViewfinderRendererMeeGo::reset() {
129   QMutexLocker locker(&m_frameMutex);
130   m_frame = -1;
131 }
132
133 GstElement *QtCamViewfinderRendererMeeGo::sinkElement() {
134   if (!QGLContext::currentContext()) {
135     qCritical() << "Cannot create the GStreamer element without an OpenGL context.";
136     return 0;
137   }
138
139   if (!m_sink) {
140     m_sink = gst_element_factory_make(m_conf->viewfinderSink().toAscii().data(),
141                                       "QtCamViewfinderRendererMeeGoSink");
142     if (!m_sink) {
143       qCritical() << "Failed to create" << m_conf->viewfinderSink();
144       return 0;
145     }
146
147     g_object_add_toggle_ref(G_OBJECT(m_sink), (GToggleNotify)sink_notify, this);
148   }
149
150   // Displa can be replaced with a null pointer.
151   // We all know that the sink used for Harmattan ignores the x-display property ;-)
152
153   Display *d = QX11Info::display();
154   g_object_set(G_OBJECT(m_sink), "x-display", d, "use-framebuffer-memory", TRUE, NULL);
155
156   EGLDisplay dpy = eglGetDisplay((EGLNativeDisplayType)d);
157   EGLContext context = eglGetCurrentContext();
158
159   g_object_set(G_OBJECT(m_sink), "egl-display", dpy, "egl-context", context, NULL);
160
161   m_id = g_signal_connect(G_OBJECT(m_sink), "frame-ready", G_CALLBACK(frame_ready), this);
162
163   GstPad *pad = gst_element_get_static_pad(m_sink, "sink");
164   m_notify = g_signal_connect(G_OBJECT(pad), "notify::caps",
165                               G_CALLBACK(sink_caps_changed), this);
166   gst_object_unref(pad);
167
168   return m_sink;
169 }
170
171 void QtCamViewfinderRendererMeeGo::frame_ready(GstElement *sink, int frame,
172                                                QtCamViewfinderRendererMeeGo *r) {
173   Q_UNUSED(sink);
174   Q_UNUSED(frame);
175
176   r->m_frameMutex.lock();
177   r->m_frame = frame;
178   r->m_frameMutex.unlock();
179
180   QMetaObject::invokeMethod(r, "updateRequested", Qt::QueuedConnection);
181 }
182
183 void QtCamViewfinderRendererMeeGo::sink_notify(QtCamViewfinderRendererMeeGo *q,
184                                                GObject *object, gboolean is_last_ref) {
185
186   Q_UNUSED(object);
187
188   if (is_last_ref) {
189     g_signal_handler_disconnect(q->m_sink, q->m_id);
190     g_object_remove_toggle_ref(G_OBJECT(q->m_sink), (GToggleNotify)sink_notify, q);
191     q->m_sink = 0;
192   }
193 }
194
195 void QtCamViewfinderRendererMeeGo::sink_caps_changed(GObject *obj, GParamSpec *pspec,
196                                                      QtCamViewfinderRendererMeeGo *q) {
197   Q_UNUSED(obj);
198   Q_UNUSED(pspec);
199
200   int width, height;
201   if (obj && gst_video_get_size  (GST_PAD(obj), &width, &height)) {
202     QMetaObject::invokeMethod(q, "setVideoSize", Qt::QueuedConnection,
203                               Q_ARG(QSizeF, QSizeF(width, height)));
204   }
205 }
206
207 void QtCamViewfinderRendererMeeGo::calculateProjectionMatrix(const QRectF& rect) {
208   m_projectionMatrix = QMatrix4x4();
209   m_projectionMatrix.ortho(rect);
210 }
211
212 void QtCamViewfinderRendererMeeGo::createProgram() {
213   if (m_program) {
214     delete m_program;
215   }
216
217   m_program = new QGLShaderProgram(this);
218
219   if (!m_program->addShaderFromSourceCode(QGLShader::Vertex, VERTEX_SHADER)) {
220     qCritical() << "Failed to add vertex shader";
221     return;
222   }
223
224   if (!m_program->addShaderFromSourceCode(QGLShader::Fragment, FRAGMENT_SHADER)) {
225     qCritical() << "Failed to add fragment shader";
226     return;
227   }
228
229   m_program->bindAttributeLocation("inputVertex", 0);
230   m_program->bindAttributeLocation("textureCoord", 1);
231
232   if (!m_program->link()) {
233     qCritical() << "Failed to link program!";
234     return;
235   }
236
237   if (!m_program->bind()) {
238     qCritical() << "Failed to bind program";
239     return;
240   }
241
242   m_program->setUniformValue("texture0", 0); // texture UNIT 0
243   m_program->release();
244 }
245
246 void QtCamViewfinderRendererMeeGo::paintFrame(QPainter *painter, int frame) {
247   if (frame == -1) {
248     return;
249   }
250
251   // TODO: sometimes there is an assertion.
252
253   MeegoGstVideoTexture *sink = MEEGO_GST_VIDEO_TEXTURE(m_sink);
254   if (!meego_gst_video_texture_acquire_frame(sink, frame)) {
255     qDebug() << "Failed to acquire frame";
256     return;
257   }
258
259   m_program->bind();
260
261   m_program->setUniformValue("matrix", m_projectionMatrix);
262   m_program->setUniformValue("matrixWorld", QMatrix4x4(painter->combinedTransform()));
263
264   if (!meego_gst_video_texture_bind_frame(sink, GL_TEXTURE_EXTERNAL_OES, frame)) {
265     qDebug() << "Failed to bind frame";
266     m_program->release();
267     return;
268   }
269
270   glEnableVertexAttribArray(0);
271   glEnableVertexAttribArray(1);
272
273   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, &m_vertexCoords);
274   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, &m_texCoords);
275
276   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
277
278   if (!meego_gst_video_texture_bind_frame(sink, GL_TEXTURE_EXTERNAL_OES, -1)) {
279     qDebug() << "Failed to unbind frame";
280   }
281
282   glDisableVertexAttribArray(1);
283   glDisableVertexAttribArray(0);
284
285   m_program->release();
286
287   // We are not using fences.
288   // TODO: make it configurable.
289   meego_gst_video_texture_release_frame(sink, frame, 0);
290 }
291
292 void QtCamViewfinderRendererMeeGo::calculateCoords() {
293   if (!m_size.isValid() || !m_videoSize.isValid()) {
294     return;
295   }
296
297   QRectF area = renderArea();
298
299   qreal leftMargin = area.x();
300   qreal topMargin = area.y();
301   QSizeF renderSize = area.size();
302
303   m_vertexCoords[0] = leftMargin;
304   m_vertexCoords[1] = topMargin + renderSize.height();
305
306   m_vertexCoords[2] = renderSize.width() + leftMargin;
307   m_vertexCoords[3] = topMargin + renderSize.height();
308
309   m_vertexCoords[4] = renderSize.width() + leftMargin;
310   m_vertexCoords[5] = topMargin;
311
312   m_vertexCoords[6] = leftMargin;
313   m_vertexCoords[7] = topMargin;
314 }
315
316 QRectF QtCamViewfinderRendererMeeGo::renderArea() {
317   if (!m_renderArea.isNull()) {
318     return m_renderArea;
319   }
320
321   QSizeF renderSize = m_videoSize;
322   renderSize.scale(m_size, Qt::KeepAspectRatio);
323
324   qreal leftMargin = (m_size.width() - renderSize.width())/2.0;
325   qreal topMargin = (m_size.height() - renderSize.height())/2.0;
326
327   m_renderArea = QRectF(QPointF(leftMargin, topMargin), renderSize);
328
329   return m_renderArea;
330 }
331
332 void QtCamViewfinderRendererMeeGo::setVideoSize(const QSizeF& size) {
333   if (size == m_videoSize) {
334     return;
335   }
336
337   m_videoSize = size;
338
339   m_renderArea = QRectF();
340
341   calculateCoords();
342
343   m_needsInit = true;
344 }