Changeset 94d2f7c in ingen


Ignore:
Timestamp:
10/24/15 22:10:37 (22 months ago)
Author:
David Robillard <d@…>
Branches:
master, groups, nodeless, parallel, parameters, sequencefix
Children:
ffae1d8
Parents:
cbd64a41
Message:

Create all graphs the same way

This ensures that subgraphs always have the standard control
ports, so they are valid Ingen graphs on their own..

git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@5783 a436a847-0d15-0410-975c-d299462d15a1

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • ingen/Resource.hpp

    rdd79e76 r94d2f7c  
    100100    virtual ~Resource() {} 
    101101 
    102     typedef std::multimap<Raul::URI, Property> Properties; 
     102    class Properties : public std::multimap<Raul::URI, Property> { 
     103    public: 
     104        Properties() {} 
     105 
     106        Properties(const Properties& copy) 
     107            : std::multimap<Raul::URI, Property>(copy) 
     108        {} 
     109 
     110        Properties(std::initializer_list<value_type> l) 
     111            : std::multimap<Raul::URI, Property>(l) 
     112        {} 
     113 
     114        void put(const Raul::URI& key, 
     115                 const Atom&      value, 
     116                 Graph            ctx = Graph::DEFAULT) { 
     117            insert(std::make_pair(key, Property(value, ctx))); 
     118        } 
     119 
     120        void put(const Raul::URI&   key, 
     121                 const URIs::Quark& value, 
     122                 Graph              ctx = Graph::DEFAULT) { 
     123            insert(std::make_pair(key, Property(value, ctx))); 
     124        } 
     125    }; 
    103126 
    104127    /** Get a single property value. 
  • src/server/CompiledGraph.hpp

    r3353177 r94d2f7c  
    2727namespace Server { 
    2828 
    29 class EdgeImpl; 
    3029class BlockImpl; 
    3130 
     
    3433class CompiledBlock { 
    3534public: 
    36     CompiledBlock(BlockImpl* b, size_t np, const std::list<BlockImpl*>& deps) 
    37         : _block(b) 
    38     { 
    39         // Copy to a vector for maximum iteration speed and cache optimization 
    40         // (Need to take a copy anyway) 
     35    CompiledBlock(BlockImpl* b) : _block(b) {} 
    4136 
    42         _dependants.reserve(deps.size()); 
    43         for (const auto& d : deps) 
    44             _dependants.push_back(d); 
    45     } 
    46  
    47     BlockImpl*                     block()       const { return _block; } 
    48     const std::vector<BlockImpl*>& dependants()  const { return _dependants; } 
     37    BlockImpl* block() const { return _block; } 
    4938 
    5039private: 
    51     BlockImpl*              _block; 
    52     std::vector<BlockImpl*> _dependants; ///< Blocks this one's output ports are connected to 
     40    BlockImpl* _block; 
    5341}; 
    5442 
  • src/server/Engine.cpp

    rc615190 r94d2f7c  
    2323#include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h" 
    2424 
    25 #include "events/CreatePort.hpp" 
     25#include "events/CreateGraph.hpp" 
    2626#include "ingen/Configuration.hpp" 
    2727#include "ingen/Log.hpp" 
     
    202202} 
    203203 
    204 static void 
    205 execute_and_delete_event(ProcessContext& context, Event* ev) 
    206 { 
    207     ev->pre_process(); 
    208     if (ev->time() < context.start()) { 
    209         // Didn't get around to executing in time, oh well... 
    210         ev->set_time(context.start()); 
    211     } 
    212     ev->execute(context); 
    213     ev->post_process(); 
    214     delete ev; 
    215 } 
    216  
    217204void 
    218205Engine::init(double sample_rate, uint32_t block_length, size_t seq_size) 
     
    236223                  buffer_factory()->default_size(_world->uris().atom_Sequence)); 
    237224 
    238     const Ingen::URIs& uris  = world()->uris(); 
    239     Forge&             forge = world()->forge(); 
    240  
    241     // Create root graph 
     225    const Ingen::URIs& uris = world()->uris(); 
     226 
    242227    if (!_root_graph) { 
    243         _root_graph = new GraphImpl( 
    244             *this, Raul::Symbol("root"), 1, NULL, _driver->sample_rate(), 1); 
    245         _root_graph->set_property( 
    246             uris.rdf_type, 
    247             Resource::Property(uris.ingen_Graph, Resource::Graph::INTERNAL)); 
    248         _root_graph->set_property( 
    249             uris.ingen_polyphony, 
    250             Resource::Property(_world->forge().make(int32_t(1)), 
    251                                Resource::Graph::INTERNAL)); 
    252         _root_graph->activate(*_buffer_factory); 
    253         _world->store()->add(_root_graph); 
    254         _root_graph->set_compiled_graph(_root_graph->compile()); 
    255  
     228        // Create root graph 
     229        Resource::Properties graph_properties; 
     230        graph_properties.insert( 
     231            make_pair(uris.rdf_type, 
     232                      Resource::Property(uris.ingen_Graph))); 
     233        graph_properties.insert( 
     234            make_pair(uris.ingen_polyphony, 
     235                      Resource::Property(_world->forge().make(1), 
     236                                         Resource::Graph::INTERNAL))); 
     237 
     238        Events::CreateGraph ev( 
     239            *this, SPtr<Interface>(), -1, 0, Raul::Path("/"), graph_properties); 
     240 
     241        // Execute in "fake" process context (we are single threaded) 
    256242        ProcessContext context(*this); 
    257  
    258         Resource::Properties control_properties; 
    259         control_properties.insert( 
    260             make_pair(uris.lv2_name, forge.alloc("Control"))); 
    261         control_properties.insert( 
    262             make_pair(uris.rdf_type, 
    263                       Resource::Property(uris.atom_AtomPort))); 
    264         control_properties.insert( 
    265             make_pair(uris.atom_bufferType, 
    266                       Resource::Property(uris.atom_Sequence))); 
    267         control_properties.insert( 
    268             make_pair(uris.rsz_minimumSize, 
    269                       // forge.make(int32_t(driver()->seq_size())))); 
    270                       forge.make(4096))); 
    271  
    272         // Add control input 
    273         Resource::Properties in_properties(control_properties); 
    274         in_properties.insert( 
    275             make_pair(uris.rdf_type, 
    276                       Resource::Property(uris.lv2_InputPort))); 
    277         in_properties.insert(make_pair(uris.lv2_index, forge.make(0))); 
    278         in_properties.insert( 
    279             make_pair(uris.lv2_portProperty, 
    280                       Resource::Property(uris.lv2_connectionOptional))); 
    281         in_properties.insert( 
    282             make_pair(uris.ingen_canvasX, 
    283                       Resource::Property(forge.make(32.0f), 
    284                                          Resource::Graph::EXTERNAL))); 
    285         in_properties.insert( 
    286             make_pair(uris.ingen_canvasY, 
    287                       Resource::Property(forge.make(32.0f), 
    288                                          Resource::Graph::EXTERNAL))); 
    289  
    290         SPtr<Interface> respondee; 
    291         execute_and_delete_event( 
    292             context, new Events::CreatePort( 
    293                 *this, respondee, -1, 0, Raul::Path("/control_in"), 
    294                 false, in_properties)); 
    295  
    296         // Add control out 
    297         Resource::Properties out_properties(control_properties); 
    298         out_properties.insert( 
    299             make_pair(uris.rdf_type, 
    300                       Resource::Property(uris.lv2_OutputPort))); 
    301         out_properties.insert(make_pair(uris.lv2_index, forge.make(1))); 
    302         in_properties.insert( 
    303             make_pair(uris.lv2_portProperty, 
    304                       Resource::Property(uris.lv2_connectionOptional))); 
    305         out_properties.insert( 
    306             make_pair(uris.ingen_canvasX, 
    307                       Resource::Property(forge.make(128.0f), 
    308                                          Resource::Graph::EXTERNAL))); 
    309         out_properties.insert( 
    310             make_pair(uris.ingen_canvasY, 
    311                       Resource::Property(forge.make(32.0f), 
    312                                          Resource::Graph::EXTERNAL))); 
    313  
    314         execute_and_delete_event( 
    315             context, new Events::CreatePort( 
    316                 *this, respondee, -1, 0, Raul::Path("/control_out"), 
    317                 true, out_properties)); 
     243        ev.pre_process(); 
     244        ev.execute(context); 
     245        ev.post_process(); 
     246 
     247        _root_graph = ev.graph(); 
    318248    } 
    319249 
  • src/server/GraphImpl.cpp

    r732bfb33 r94d2f7c  
    250250    BlockImpl::set_buffer_size(context, bufs, type, size); 
    251251 
    252     for (size_t i = 0; i < _compiled_graph->size(); ++i) 
    253         (*_compiled_graph)[i].block()->set_buffer_size(context, bufs, type, size); 
     252    if (_compiled_graph) { 
     253        for (size_t i = 0; i < _compiled_graph->size(); ++i) { 
     254            const CompiledBlock& block = (*_compiled_graph)[i]; 
     255            block.block()->set_buffer_size(context, bufs, type, size); 
     256        } 
     257    } 
    254258} 
    255259 
     
    363367            compile_recursive(p, output); 
    364368 
    365     output->push_back(CompiledBlock(n, n->providers().size(), n->dependants())); 
     369    output->push_back(CompiledBlock(n)); 
    366370} 
    367371 
  • src/server/events/CreateGraph.cpp

    r1831955 r94d2f7c  
    2525#include "GraphImpl.hpp" 
    2626#include "events/CreateGraph.hpp" 
     27#include "events/CreatePort.hpp" 
    2728 
    2829namespace Ingen { 
     
    4445{} 
    4546 
     47void 
     48CreateGraph::build_child_events() 
     49{ 
     50    const Ingen::URIs& uris = _engine.world()->uris(); 
     51 
     52    // Properties common to both ports 
     53    Resource::Properties control_properties; 
     54    control_properties.put(uris.lv2_name, uris.forge.alloc("Control")); 
     55    control_properties.put(uris.rdf_type, uris.atom_AtomPort); 
     56    control_properties.put(uris.atom_bufferType, uris.atom_Sequence); 
     57    control_properties.put(uris.rsz_minimumSize, uris.forge.make(4096)); 
     58    control_properties.put(uris.lv2_portProperty, uris.lv2_connectionOptional); 
     59 
     60    // Add control input 
     61    Resource::Properties in_properties(control_properties); 
     62    in_properties.put(uris.rdf_type, uris.lv2_InputPort); 
     63    in_properties.put(uris.lv2_index, uris.forge.make(0)); 
     64    in_properties.put(uris.ingen_canvasX, uris.forge.make(32.0f), 
     65                      Resource::Graph::EXTERNAL); 
     66    in_properties.put(uris.ingen_canvasY, uris.forge.make(32.0f), 
     67                      Resource::Graph::EXTERNAL); 
     68 
     69    _child_events.push_back( 
     70        SPtr<Events::CreatePort>( 
     71            new Events::CreatePort( 
     72                _engine, _request_client, -1, _time, 
     73                _path.child(Raul::Symbol("control_in")), 
     74                in_properties))); 
     75 
     76    // Add control out 
     77    Resource::Properties out_properties(control_properties); 
     78    out_properties.put(uris.rdf_type, uris.lv2_OutputPort); 
     79    out_properties.put(uris.lv2_index, uris.forge.make(1)); 
     80    out_properties.put(uris.ingen_canvasX, uris.forge.make(128.0f), 
     81                       Resource::Graph::EXTERNAL); 
     82    out_properties.put(uris.ingen_canvasY, uris.forge.make(32.0f), 
     83                       Resource::Graph::EXTERNAL); 
     84 
     85    _child_events.push_back( 
     86        SPtr<Events::CreatePort>( 
     87            new Events::CreatePort(_engine, _request_client, -1, _time, 
     88                                   _path.child(Raul::Symbol("control_out")), 
     89                                   out_properties))); 
     90} 
     91 
    4692bool 
    4793CreateGraph::pre_process() 
    4894{ 
    49     if (_path.is_root() || _engine.store()->get(_path)) { 
     95    if (_engine.store()->get(_path)) { 
    5096        return Event::pre_process_done(Status::EXISTS, _path); 
    5197    } 
    5298 
    53     _parent = dynamic_cast<GraphImpl*>(_engine.store()->get(_path.parent())); 
    54     if (!_parent) { 
    55         return Event::pre_process_done(Status::PARENT_NOT_FOUND, _path.parent()); 
     99    if (!_path.is_root()) { 
     100        const Raul::Path up(_path.parent()); 
     101        if (!(_parent = dynamic_cast<GraphImpl*>(_engine.store()->get(up)))) { 
     102            return Event::pre_process_done(Status::PARENT_NOT_FOUND, up); 
     103        } 
    56104    } 
    57105 
     
    71119    } 
    72120 
    73     if (int_poly == _parent->internal_poly()) { 
     121    if (!_parent || int_poly == _parent->internal_poly()) { 
    74122        ext_poly = int_poly; 
    75123    } 
    76124 
    77     const Raul::Symbol symbol((_path.is_root()) ? "root" : _path.symbol()); 
     125    const Raul::Symbol symbol(_path.is_root() ? "graph" : _path.symbol()); 
    78126 
    79127    // Get graph prototype 
     
    109157    _graph->set_properties(_properties); 
    110158 
    111     _parent->add_block(*_graph); 
    112     if (_parent->enabled()) { 
    113         _graph->enable(); 
    114         _compiled_graph = _parent->compile(); 
     159    if (_parent) { 
     160        // Add graph to parent 
     161        _parent->add_block(*_graph); 
     162        if (_parent->enabled()) { 
     163            _graph->enable(); 
     164            _compiled_graph = _parent->compile(); 
     165        } 
    115166    } 
    116167 
     
    124175    } 
    125176 
     177    // Build and pre-process child events to create standard ports 
     178    build_child_events(); 
     179    for (SPtr<Event> ev : _child_events) { 
     180        ev->pre_process(); 
     181    } 
     182 
    126183    return Event::pre_process_done(Status::SUCCESS); 
    127184} 
     
    131188{ 
    132189    if (_graph) { 
    133         _parent->set_compiled_graph(_compiled_graph); 
     190        if (_parent) { 
     191            _parent->set_compiled_graph(_compiled_graph); 
     192        } 
     193 
     194        for (SPtr<Event> ev : _child_events) { 
     195            ev->execute(context); 
     196        } 
    134197    } 
    135198} 
     
    142205        _update.send(_engine.broadcaster()); 
    143206    } 
     207 
     208    if (_graph) { 
     209        for (SPtr<Event> ev : _child_events) { 
     210            ev->post_process(); 
     211        } 
     212    } 
     213    _child_events.clear(); 
    144214} 
    145215 
  • src/server/events/CreateGraph.hpp

    r3353177 r94d2f7c  
    4949    void post_process(); 
    5050 
     51    GraphImpl* graph() { return _graph; } 
     52 
    5153private: 
    52     const Raul::Path      _path; 
    53     Resource::Properties  _properties; 
    54     Events::Get::Response _update; 
    55     GraphImpl*            _graph; 
    56     GraphImpl*            _parent; 
    57     CompiledGraph*        _compiled_graph; 
     54    void build_child_events(); 
     55 
     56    const Raul::Path         _path; 
     57    Resource::Properties     _properties; 
     58    Events::Get::Response    _update; 
     59    GraphImpl*               _graph; 
     60    GraphImpl*               _parent; 
     61    CompiledGraph*           _compiled_graph; 
     62    std::list< SPtr<Event> > _child_events; 
    5863}; 
    5964 
  • src/server/events/CreatePort.cpp

    rcbd64a41 r94d2f7c  
    4242                       SampleCount                 timestamp, 
    4343                       const Raul::Path&           path, 
    44                        bool                        is_output, 
    4544                       const Resource::Properties& properties) 
    4645    : Event(engine, client, id, timestamp) 
     
    5453    , _engine_port(NULL) 
    5554    , _properties(properties) 
    56     , _is_output(is_output) 
    5755{ 
    5856    const Ingen::URIs& uris = _engine.world()->uris(); 
     
    7270        } else if (type == uris.atom_AtomPort) { 
    7371            _port_type = PortType::ATOM; 
     72        } else if (type == uris.lv2_InputPort) { 
     73            _flow = Flow::INPUT; 
     74        } else if (type == uris.lv2_OutputPort) { 
     75            _flow = Flow::OUTPUT; 
    7476        } 
    7577    } 
     
    8890{ 
    8991    if (_port_type == PortType::UNKNOWN) { 
     92        return Event::pre_process_done(Status::UNKNOWN_TYPE, _path); 
     93    } else if (!_flow) { 
    9094        return Event::pre_process_done(Status::UNKNOWN_TYPE, _path); 
    9195    } else if (_path.is_root()) { 
     
    137141                                 polyphonic, 
    138142                                 _port_type, _buf_type, buf_size, 
    139                                  value, _is_output); 
     143                                 value, _flow == Flow::OUTPUT); 
    140144 
    141145    _graph_port->properties().insert(_properties.begin(), _properties.end()); 
    142146 
    143147    _engine.store()->add(_graph_port); 
    144     if (_is_output) { 
     148    if (_flow == Flow::OUTPUT) { 
    145149        _graph->add_output(*_graph_port); 
    146150    } else { 
  • src/server/events/CreatePort.hpp

    r3353177 r94d2f7c  
    1717#ifndef INGEN_EVENTS_CREATEPORT_HPP 
    1818#define INGEN_EVENTS_CREATEPORT_HPP 
     19 
     20#include <boost/optional.hpp> 
    1921 
    2022#include "ingen/Resource.hpp" 
     
    4850               SampleCount                 timestamp, 
    4951               const Raul::Path&           path, 
    50                bool                        is_output, 
    5152               const Resource::Properties& properties); 
    5253 
     
    5657 
    5758private: 
     59    enum class Flow { 
     60        INPUT, 
     61        OUTPUT 
     62    }; 
     63 
    5864    Raul::Path              _path; 
    5965    PortType                _port_type; 
     
    6672    Resource::Properties    _properties; 
    6773    Resource::Properties    _update; 
    68     bool                    _is_output; 
     74    boost::optional<Flow>   _flow; 
    6975}; 
    7076 
  • src/server/events/Delta.cpp

    r1831955 r94d2f7c  
    202202            _create_event = new CreatePort( 
    203203                _engine, _request_client, _request_id, _time, 
    204                 path, is_output, _properties); 
     204                path, _properties); 
    205205        } 
    206206        if (_create_event) { 
Note: See TracChangeset for help on using the changeset viewer.