Merge branch 'release_0.5.6'

Author: paperManu

CMakeLists.txt

@@ -20,7 +20,7 @@
 cmake_minimum_required(VERSION 3.2)
 project(
     splash 
-    VERSION 0.5.4
+    VERSION 0.5.6
     LANGUAGES C CXX
 )
 

NEWS

@@ -1,6 +1,24 @@
 Splash release notes
 ===================
 
+Splash 0.5.6 (2017-02-10)
+-------------------------
+New features:
+* Refactored ImageBufferSpec to add support for YUV (and other formats). Updated other classes to reflect this change
+
+Improvements:
+* Added _tex#_size uniform for Texture_Images
+* Blender addon can now export a project (and not the whole configuration)
+* Refactored ImageBufferSpec to add support for YUV (and other formats). Updated other classes to reflect this change
+
+Bug fixed:
+* Fixed videos looping before the end
+* Fixed issues with planar audio having only the first channel decoded
+* Fixed audio sync
+* Fixed GUI creating a Python interpreter in every Scene: only the master Scene is worthy
+* Fixed a segfault when quitting
+* Fixed partly deadlocks occuring when modifying heavily the configuration at runtime
+
 Splash 0.5.4 (2017-01-30)
 -------------------------
 New features:

addons/blender/splash/__init__.py

@@ -20,7 +20,7 @@
 bl_info = {
     "name": "Splash output",
     "author": "Emmanuel Durand",
-    "version": (0, 5, 4),
+    "version": (0, 5, 6),
     "blender": (2, 72, 0),
     "location": "3D View > Toolbox, File > Export",
     "description": "Utility tools to connect Blender to the Splash videomapper",

addons/blender/splash/nodes.py

@@ -489,8 +489,13 @@ def draw_buttons(self, context, layout):
         row = layout.row()
         row.prop(self, "name")
         row = layout.row()
-        operator = row.operator("splash.export_node_tree", text="Export tree")
+        operator = row.operator("splash.export_node_tree", text="Export configuration")
         operator.node_name = self.name
+        operator.export_project = False
+        row = layout.row()
+        operator = row.operator("splash.export_node_tree", text="Export project")
+        operator.node_name = self.name
+        operator.export_project = True
 
     def init(self, context):
         self.inputs.new('NodeSocketInt', 'Refresh rate').default_value = 60

addons/blender/splash/operators.py

@@ -297,21 +297,27 @@ def execute(self, context):
 
 
 class SplashExportNodeTree(Operator):
-    """Exports the Splash configuration (following the tree starting from this node)"""
+    """Exports the Splash configuration or project (following the tree starting from this node)"""
     bl_idname = "splash.export_node_tree"
     bl_label = "Exports the node tree"
 
+
     filepath = bpy.props.StringProperty(subtype='FILE_PATH')
     filter_glob = bpy.props.StringProperty(
         default="*.json",
         options={'HIDDEN'},
         )
 
     node_name = StringProperty(name='Node name', description='Name of the calling node', default='')
+    export_project = BoolProperty(name='export_project')
+
     world_node = None
     scene_order = []
     scene_lists = {}
     node_links = {}
+    project_accepted_types = ['SplashImageNodeType',
+                              'SplashMeshNodeType',
+                              'SplashObjectNodeType']
 
     def execute(self, context):
         self.scene_order.clear()
@@ -330,72 +336,91 @@ def execute(self, context):
         for scene in connectedScenes:
             scene_list = {}
             node_links = []
-            self.parseTree(scene, scene_list, node_links)
+            self.parseTree(scene, scene_list, node_links, self.export_project)
 
             self.scene_order.append(scene.name)
             self.scene_lists[scene.name] = scene_list
             self.node_links[scene.name] = node_links
 
-        print(self.scene_order)
-        return self.export()
+        # Merge scenes info if exporting a project
+        if self.export_project and len(self.scene_order) > 0:
+            masterSceneName = self.scene_order[0]
+            for sceneId in range(1, len(self.scene_order)):
+                sceneName = self.scene_order[sceneId]
+
+                for node in self.scene_lists[sceneName]:
+                    if node not in self.scene_lists[masterSceneName]:
+                        self.scene_lists[masterSceneName][node] = self.scene_lists[sceneName][node]
+                for link in self.node_links[sceneName]:
+                    self.node_links[masterSceneName].append(link)
+
+            self.scene_order = [self.scene_order[0]]
+            self.scene_lists = {masterSceneName : self.scene_lists[masterSceneName]}
+
+        return self.export(self.export_project)
 
-    def parseTree(self, node, scene_list, node_links):
-        scene_list[node.name] = node
+    def parseTree(self, node, scene_list, node_links, export_project=False):
+        if not export_project or node.bl_idname in self.project_accepted_types:
+            scene_list[node.name] = node
 
         connectedNodes = [socket.links[0].from_node for socket in node.inputs if socket.is_linked]
         for connectedNode in connectedNodes:
             newLink = [connectedNode.name, node.name]
             if newLink not in node_links:
                 node_links.append([connectedNode.name, node.name])
-            self.parseTree(connectedNode, scene_list, node_links)
+            self.parseTree(connectedNode, scene_list, node_links, export_project)
 
-    def export(self):
+    def export(self, export_project=False):
         file = open(self.filepath, "w", encoding="utf8", newline="\n")
         fw = file.write
 
-        # World informations
         worldArgs =  self.world_node.exportProperties(self.filepath)
         fw("// Splash configuration file\n"
            "// Exported with Blender Splash add-on\n"
-           "{\n"
-           "    \"encoding\" : \"UTF-8\",\n"
-           "    \"description\" : \"splashConfiguration\",\n"
-           "\n"
-           "    \"world\" : {\n"
-           "        \"framerate\" : %i\n"
-           "    },\n" % (worldArgs['framerate']))
-
-        # Scenes list
-        fw("    \"scenes\" : [\n")
-        sceneIndex = 0
-        for scene in self.scene_order:
-            # Find the Scene nodes
-            for node in self.scene_lists[scene]:
-                if self.scene_lists[scene][node].bl_idname == "SplashSceneNodeType":
-                    args = self.scene_lists[scene][node].exportProperties(self.filepath)
-                    fw("        {\n")
-                    valueIndex = 0
-                    for values in args:
-                        fw("            \"%s\" : %s" % (values, args[values]))
+           "{\n")
 
-                        if valueIndex < len(args) - 1:
+        if export_project:
+            fw("    \"description\" : \"splashProject\",\n")
+        else:
+            fw("    \"description\" : \"splashConfiguration\",\n")
+            # World informations
+            fw("    \"world\" : {\n"
+               "        \"framerate\" : %i\n"
+               "    },\n" % (worldArgs['framerate']))
+
+            # Scenes list
+            fw("    \"scenes\" : [\n")
+            sceneIndex = 0
+            for scene in self.scene_order:
+                # Find the Scene nodes
+                for node in self.scene_lists[scene]:
+                    if self.scene_lists[scene][node].bl_idname == "SplashSceneNodeType":
+                        args = self.scene_lists[scene][node].exportProperties(self.filepath)
+                        fw("        {\n")
+                        valueIndex = 0
+                        for values in args:
+                            fw("            \"%s\" : %s" % (values, args[values]))
+
+                            if valueIndex < len(args) - 1:
+                                fw(",\n")
+                            else:
+                                fw("\n")
+                            valueIndex = valueIndex + 1
+                        fw("        }")
+
+                        if sceneIndex < len(self.scene_lists) - 1:
                             fw(",\n")
                         else:
                             fw("\n")
-                        valueIndex = valueIndex + 1
-                    fw("        }")
-
-                    if sceneIndex < len(self.scene_lists) - 1:
-                        fw(",\n")
-                    else:
-                        fw("\n")
-                    sceneIndex = sceneIndex + 1
-        fw("    ],\n")
+                        sceneIndex = sceneIndex + 1
+            fw("    ],\n")
 
         # Scenes information
         sceneIndex = 0
         for scene in self.scene_order:
-            fw("    \"%s\" : {\n" % scene)
+            if not export_project:
+                fw("    \"%s\" : {\n" % scene)
+
             for node in self.scene_lists[scene]:
                 if self.scene_lists[scene][node].bl_idname != "SplashSceneNodeType":
                     args = self.scene_lists[scene][node].exportProperties(self.filepath)
@@ -429,7 +454,8 @@ def export(self):
                 fw("    }\n")
             sceneIndex = sceneIndex + 1
 
-        fw("}")
+        if not export_project:
+            fw("}")
 
         return {'FINISHED'}
 

external/ffmpeg

@@ -489,6 +489,11 @@ class BaseObject
      */
     AttributeFunctor& addAttribute(const std::string& name, std::function<bool(const Values&)> set, std::function<const Values()> get, const std::vector<char>& types = {});
 
+    /**
+     * \brief Register new attributes
+     */
+    void registerAttributes();
+
     /**
      * \brief Set and the description for the given attribute, if it exists
      * \param name Attribute name
@@ -534,6 +539,7 @@ class BufferObject : public BaseObject
     BufferObject(std::weak_ptr<RootObject> root)
         : BaseObject(root)
     {
+        registerAttributes();
     }
 
     /**
@@ -603,13 +609,23 @@ class BufferObject : public BaseObject
 
     std::shared_ptr<SerializedObject> _serializedObject; //!< Internal buffer object
     bool _newSerializedObject{false};                    //!< Set to true during serialized object processing
+
+    /**
+     * \brief Register new attributes
+     */
+    void registerAttributes() { BaseObject::registerAttributes(); }
 };
 
+class UserInput;
+class ControllerObject;
+
 /*************/
 //! Base class for root objects: World and Scene
 class RootObject : public BaseObject
 {
-    friend BaseObject; //!< Base objects can access protected members, typically _objects
+    // UserInput and ControllerObject can access protected members, typically _objects
+    friend UserInput;
+    friend ControllerObject;
 
   public:
     /**
@@ -705,6 +721,7 @@ class RootObject : public BaseObject
     // Tasks queue
     std::recursive_mutex _taskMutex;
     std::list<std::function<void()>> _taskQueue;
+    std::mutex _recurringTaskMutex;
     std::map<std::string, std::function<void()>> _recurringTasks;
 
     /**

include/basetypes.h

@@ -46,6 +46,7 @@ class ControllerObject : public BaseObject
     ControllerObject(std::weak_ptr<RootObject> root)
         : BaseObject(root)
     {
+        registerAttributes();
     }
 
     /**
@@ -164,6 +165,12 @@ class ControllerObject : public BaseObject
      * \param cb Callback
      */
     void setUserInputCallback(const UserInput::State& state, std::function<void(const UserInput::State&)> cb) const;
+
+  protected:
+    /**
+     * \brief Register new functors to modify attributes
+     */
+    void registerAttributes() { BaseObject::registerAttributes(); }
 };
 
 } // end of namespace

include/controller.h

@@ -112,6 +112,7 @@ class Factory
 
     std::weak_ptr<RootObject> _root;         //!< Root object, used as root for all created objects
     bool _isScene{false};                    //!< True if the root is a Scene, false if it is a World (or if there is no root)
+    bool _isMasterScene{false};              //!< True if the root is the master Scene
     std::map<std::string, Page> _objectBook; //!< List of all creatable objects
 
     /**

include/factory.h

@@ -90,7 +90,7 @@ class Filter : public Texture
      * \brief Get specs of the texture
      * \return Return the texture specs
      */
-    ImageBufferSpec getSpec() const { return _outTextureSpec; }
+    ImageBufferSpec getSpec() const { return _outTexture->getSpec(); }
 
     /**
      * \brief Try to link the given BaseObject to this object
@@ -131,9 +131,10 @@ class Filter : public Texture
     ImageBufferSpec _outTextureSpec;
 
     // Filter parameters
-    std::map<std::string, Values> _filterUniforms; //!< Contains all filter uniforms
-    bool _render16bits{false};                     //!< Set to true for the filter to be rendered in 16bits
-    bool _updateColorDepth{false};                 //!< Set to true if the _render16bits has been updated
+    std::unordered_map<std::string, Values> _filterUniforms; //!< Contains all filter uniforms
+    std::string _pixelFormat{"RGBA"};                        //!< Output pixel format
+    bool _render16bits{false};                               //!< Set to true for the filter to be rendered in 16bits
+    bool _updateColorDepth{false};                           //!< Set to true if the _render16bits has been updated
 
     std::string _shaderSource{""};     //!< User defined fragment shader filter
     std::string _shaderSourceFile{""}; //!< User defined fragment shader filter source file