Changeset 94d2f7c in ingen


Ignore:
Timestamp:
Oct 24, 2015, 10:10:37 PM (2 years ago)
Author:
David Robillard <d@…>
Branches:
groups, master, nodeless, parallel, parameters, sequencefix, tasks
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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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

    rcbd64a41 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.