Merge lp:~phablet-team/qtvideo-node/media-hub-3 into lp:qtvideo-node

[Ricardo Mendoza]

Adjust to new mh3 interfaces.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:58
http://jenkins.qa.ubuntu.com/job/qtvideo-node-ci/61/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtvideo-node-vivid-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtvideo-node-vivid-armhf-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtvideo-node-vivid-i386-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtvideo-node-ci/61/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

58. By Ricardo Mendoza on 2015-03-16

Merge trunk

=== modified file 'debian/control'
--- debian/control	2015-03-12 22:20:19 +0000
+++ debian/control	2015-03-16 21:23:34 +0000
@@ -6,6 +6,7 @@
                libgl1-mesa-dev[!armhf],
                libgles2-mesa-dev[armhf],
                libhybris-dev (>=0.1.0+git20131207+e452e83-0ubuntu3),
+               libmedia-hub-dev(>=3.0.0),
                libplatform-api-headers | ubuntu-platform-api-headers,
                libpulse-dev,
                libqt5opengl5-dev,

=== modified file 'src/shadervideomaterial.cpp'
--- src/shadervideomaterial.cpp	2015-03-09 11:32:10 +0000
+++ src/shadervideomaterial.cpp	2015-03-16 21:23:34 +0000
@@ -30,6 +30,8 @@
 #include "shadervideomaterial.h"
 #include "shadervideoshader.h"
 
+#include <core/media/video/sink.h>
+
 #include <camera_compatibility_layer.h>
 #include <qtubuntu_media_signals.h>
 #include <surface_texture_client_hybris.h>
@@ -41,7 +43,6 @@
       m_camControl(0),
       m_textureId(0),
       m_surfaceTextureClient(0),
-      m_glConsumer(0),
       m_readyToRender(false),
       m_orientation(SharedSignal::Orientation::rotate0)
 {
@@ -107,21 +108,21 @@
     m_surfaceTextureClient = surface_texture_client;
 }
 
-void ShaderVideoMaterial::setGLConsumer(GLConsumerWrapperHybris gl_consumer)
+void ShaderVideoMaterial::setGLVideoSink(const std::shared_ptr<core::ubuntu::media::video::Sink>& sink)
 {
-    m_glConsumer = gl_consumer;
+    m_videoSink = sink;
 }
 
-GLConsumerWrapperHybris ShaderVideoMaterial::glConsumer() const
+const std::shared_ptr<core::ubuntu::media::video::Sink>& ShaderVideoMaterial::glVideoSink() const
 {
-    return m_glConsumer;
+    return m_videoSink;
 }
 
 bool ShaderVideoMaterial::updateTexture()
 {
     bool textureDirty = false;
 
-    if (!m_camControl && !m_textureId && !m_glConsumer) {
+    if (!m_camControl && !m_textureId && !m_videoSink) {
         return false;
     }
 
@@ -129,12 +130,13 @@
         android_camera_update_preview_texture(m_camControl);
         android_camera_get_preview_texture_transformation(m_camControl, m_textureMatrix);
         textureDirty = true;
-    } else if (m_glConsumer != NULL && !m_readyToRender) {
+    } else if (m_videoSink && !m_readyToRender) {
         m_readyToRender = true;
-    } else if (m_glConsumer != NULL && m_readyToRender) {
-        gl_consumer_update_texture(m_glConsumer);
-        gl_consumer_get_transformation_matrix(m_glConsumer, static_cast<float*>(m_textureMatrix));
-        textureDirty = true;
+    } else if (m_videoSink && m_readyToRender) {
+        if (m_videoSink->swap_buffers()) {
+            m_videoSink->transformation_matrix(static_cast<float*>(m_textureMatrix));
+            textureDirty = true;
+        }
     }
 
     // See if the video needs rotation

=== modified file 'src/shadervideomaterial.h'
--- src/shadervideomaterial.h	2014-10-16 01:45:58 +0000
+++ src/shadervideomaterial.h	2015-03-16 21:23:34 +0000
@@ -29,6 +29,12 @@
 #include <QVideoSurfaceFormat>
 #include <qtubuntu_media_signals.h>
 
+#include <memory>
+
+namespace core { namespace ubuntu { namespace media { namespace video {
+class Sink;
+} } } }
+
 struct CameraControl;
 struct MediaPlayerWrapper;
 class ShaderVideoShader;
@@ -53,8 +59,8 @@
     GLuint textureId() const { return m_textureId; }
 
     void setSurfaceTextureClient(SurfaceTextureClientHybris surface_texture_client);
-    void setGLConsumer(GLConsumerWrapperHybris gl_consumer);
-    GLConsumerWrapperHybris glConsumer() const;
+    void setGLVideoSink(const std::shared_ptr<core::ubuntu::media::video::Sink>& sink);
+    const std::shared_ptr<core::ubuntu::media::video::Sink>& glVideoSink() const;
 
     bool updateTexture();
 
@@ -73,7 +79,7 @@
     CameraControl *m_camControl;
     GLuint m_textureId;
     SurfaceTextureClientHybris m_surfaceTextureClient;
-    GLConsumerWrapperHybris m_glConsumer;
+    std::shared_ptr<core::ubuntu::media::video::Sink> m_videoSink;
     bool m_readyToRender;
     static ShaderVideoShader *m_videoShader; // the shader is cached in the Qt scene graph
     SharedSignal::Orientation m_orientation;

=== modified file 'src/shadervideonode.cpp'
--- src/shadervideonode.cpp	2014-10-16 02:37:25 +0000
+++ src/shadervideonode.cpp	2015-03-16 21:23:34 +0000
@@ -28,8 +28,7 @@
  */
 ShaderVideoNode::ShaderVideoNode(const QVideoSurfaceFormat &format) :
     m_format(format),
-    m_textureId(0),
-    m_glConsumer(0)
+    m_textureId(0)
 {
     m_material = new ShaderVideoMaterial(format);
     setMaterial(m_material);
@@ -73,13 +72,12 @@
             return;
         }
         m_material->setCamControl((CameraControl*)ci);
-    } else if (frame.availableMetaData().contains("GLConsumer")) {
+    } else if (frame.availableMetaData().contains("GLVideoSink")) {
         qDebug() << "** Setting GLConsumer instance";
-        m_glConsumer = reinterpret_cast<GLConsumerWrapperHybris>(
-            frame.metaData("GLConsumer").value<unsigned int>());
-        m_material->setGLConsumer(m_glConsumer);
-        if (m_glConsumer == 0) {
-            qWarning() << "No valid GLConsumerWrapperHybris instance in video frame";
+        auto sink = frame.metaData("GLVideoSink").value<std::shared_ptr<core::ubuntu::media::video::Sink>>();
+        m_material->setGLVideoSink(sink);
+        if (not sink) {
+            qWarning() << "No valid GL video sink instance in video frame";
             return;
         }
 

=== modified file 'src/shadervideonode.h'
--- src/shadervideonode.h	2014-03-25 21:13:55 +0000
+++ src/shadervideonode.h	2015-03-16 21:23:34 +0000
@@ -21,6 +21,12 @@
 #include <QObject>
 #include <private/qsgvideonode_p.h>
 
+#include <memory>
+
+namespace core { namespace ubuntu { namespace media { namespace video {
+class Sink;
+} } } }
+
 class CameraControl;
 class ShaderVideoMaterial;
 class SnapshotGenerator;
@@ -48,8 +54,10 @@
     QVideoSurfaceFormat m_format;
     ShaderVideoMaterial *m_material;
     GLuint m_textureId;
-    GLConsumerWrapperHybris m_glConsumer;
+    std::shared_ptr<core::ubuntu::media::video::Sink> m_videoSink;
     SnapshotGenerator *m_snapshotGenerator;
 };
 
+Q_DECLARE_METATYPE(std::shared_ptr<core::ubuntu::media::video::Sink>);
+
 #endif // SHADERVIDEONODE_H

=== modified file 'src/src.pro'
--- src/src.pro	2014-10-16 02:37:25 +0000
+++ src/src.pro	2015-03-16 21:23:34 +0000
@@ -13,7 +13,7 @@
 INSTALLS = target
 
 INCLUDEPATH += /usr/include/hybris/camera /usr/include/hybris/media /usr/include/libqtubuntu-media-signals
-LIBS += -lhybris_ics -lcamera -lmedia -lqtubuntu-media-signals
+LIBS += -lhybris_ics -lcamera -lmedia -lqtubuntu-media-signals -lmedia-hub-client
 
 OTHER_FILES += shadervideonode.json
 

=== modified file 'unittests/shadervideonode/tst_shadervideonode.cpp'
--- unittests/shadervideonode/tst_shadervideonode.cpp	2014-04-08 14:04:27 +0000
+++ unittests/shadervideonode/tst_shadervideonode.cpp	2015-03-16 21:23:34 +0000
@@ -22,6 +22,8 @@
 
 #include <shadervideomaterial.h>
 
+#include <core/media/video/sink.h>
+
 #include <qtubuntu_media_signals.h>
 
 #include "camera_compatibility_layer.h"
@@ -31,6 +33,8 @@
 
 #include "shadervideonode.h"
 
+namespace
+{
 class tst_ShaderVideoNode : public QObject
 {
     Q_OBJECT
@@ -76,6 +80,26 @@
     unsigned int m_textureId;
 };
 
+struct NullSink : public core::ubuntu::media::video::Sink
+{
+    const core::Signal<void>& frame_available() const
+    {
+        static core::Signal<void> sig; return sig;
+    }
+
+    bool transformation_matrix(float*) const
+    {
+        return true;
+    }
+
+    bool swap_buffers() const
+    {
+        return true;
+    }
+};
+
+}
+
 void tst_ShaderVideoNode::initTestCase()
 {
     m_glConsumerSet = false;
@@ -114,12 +138,11 @@
 
     node.setCurrentFrame(frame);
 
-    GLConsumerWrapperHybris *gl_consumer = new GLConsumerWrapperHybris;
+    std::shared_ptr<core::ubuntu::media::video::Sink> sink{new NullSink()};
 
-    frame.setMetaData("GLConsumer", QVariant::fromValue(reinterpret_cast<uint64_t>(gl_consumer)));
+    frame.setMetaData("GLVideoSink", QVariant::fromValue(sink));
     node.setCurrentFrame(frame);
-    QCOMPARE(QVariant(QMetaType::VoidStar, node.m_material->glConsumer()),
-             QVariant(QMetaType::VoidStar, gl_consumer));
+    QCOMPARE(node.m_material->glVideoSink(), sink);
 
     QVERIFY(m_glConsumerSet == true);
 }