Changeset 3976


Ignore:
Timestamp:
2012-02-07 18:34:23 (2 years ago)
Author:
drobilla
Message:

Update for latest Atom extension.
Probably fix #802.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/ingen/src/server/AudioBuffer.cpp

    r3566 r3976  
    5555        assert(type == PortType::AUDIO); 
    5656        atom()->type = 0;//map->vector_type; 
    57         LV2_Atom_Vector* body = (LV2_Atom_Vector*)atom()->body; 
     57        LV2_Atom_Vector* body = (LV2_Atom_Vector*)LV2_ATOM_BODY(atom()); 
    5858        body->elem_count = size / sizeof(Sample); 
    5959        body->elem_type = 0;//map->float_type; 
  • trunk/ingen/src/server/AudioBuffer.hpp

    r3475 r3976  
    5353    inline Sample* data() const { 
    5454        return (is_control()) 
    55                 ? (Sample*)atom()->body 
    56                 : (Sample*)(atom()->body + sizeof(LV2_Atom_Vector)); 
     55            ? (Sample*)LV2_ATOM_BODY(atom()) 
     56            : (Sample*)LV2_ATOM_CONTENTS(LV2_Atom_Vector, atom()); 
    5757    } 
    5858 
     
    7474    enum State { OK, HALF_SET_CYCLE_1, HALF_SET_CYCLE_2 }; 
    7575 
    76     LV2_Atom_Vector* vector() { return(LV2_Atom_Vector*)atom()->body; } 
     76    LV2_Atom_Vector* vector() { return (LV2_Atom_Vector*)atom(); } 
    7777 
    7878    State     _state;     ///< State of buffer for setting values next cycle 
  • trunk/ingen/src/server/BufferFactory.cpp

    r3854 r3976  
    142142        AudioBuffer* ret = new AudioBuffer(*this, type, audio_buffer_size(size)); 
    143143        ret->atom()->type = _uris->atom_Vector.id; 
    144         ((LV2_Atom_Vector*)ret->atom()->body)->elem_type = _uris->atom_Float32.id; 
     144        ((LV2_Atom_Vector*)LV2_ATOM_BODY(ret->atom()))->elem_type = _uris->atom_Float32.id; 
    145145        buffer = ret; 
    146146    } else if (type.is_events()) { 
  • trunk/ingen/src/server/ObjectBuffer.cpp

    r3963 r3976  
    103103        switch (_type.symbol()) { 
    104104            case PortType::CONTROL: 
    105                 return (float*)atom()->body; 
     105                return (float*)LV2_ATOM_BODY(atom()); 
    106106            case PortType::AUDIO: 
    107                 return (float*)((LV2_Atom_Vector*)atom()->body)->elems + offset; 
     107                return (float*)LV2_ATOM_CONTENTS(LV2_Atom_Vector, atom()) + offset; 
    108108            default: 
    109109                warn << "Audio data requested from non-audio buffer" << endl; 
     
    124124        switch (_type.symbol()) { 
    125125            case PortType::CONTROL: 
    126                 return (float*)atom()->body; 
     126                return (float*)LV2_ATOM_BODY(atom()); 
    127127            case PortType::AUDIO: 
    128                 return (float*)((LV2_Atom_Vector*)atom()->body)->elems + offset; 
     128                return (float*)LV2_ATOM_CONTENTS(LV2_Atom_Vector, atom()) + offset; 
    129129            default: 
    130130                warn << "Audio data requested from non-audio buffer" << endl; 
  • trunk/jalv/src/jalv.c

    r3963 r3976  
    178178        port->old_api = true; 
    179179    } else if (lilv_port_is_a(host->plugin, port->lilv_port, 
    180                               host->aevent_class)) { 
     180                              host->msg_port_class)) { 
    181181        port->type = TYPE_EVENT; 
    182182        port->old_api = false; 
     
    395395                const LV2_Atom* const atom = (const LV2_Atom*)body; 
    396396                lv2_evbuf_write(&i, nframes, 0, 
    397                                 atom->type, atom->size, atom->body); 
     397                                atom->type, atom->size, LV2_ATOM_BODY(atom)); 
    398398            } else { 
    399399                fprintf(stderr, "error: Unknown control change protocol %d\n", 
     
    423423            jack_midi_clear_buffer(buf); 
    424424 
    425             LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf); 
    426             const uint32_t     count = lv2_evbuf_get_event_count(iter.evbuf); 
    427             for (uint32_t i = 0; i < count; ++i) { 
     425            for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf); 
     426                 lv2_evbuf_is_valid(i); 
     427                 i = lv2_evbuf_next(i)) { 
    428428                uint32_t frames, subframes, type, size; 
    429429                uint8_t* data; 
    430                 lv2_evbuf_get(iter, &frames, &subframes, 
     430                lv2_evbuf_get(i, &frames, &subframes, 
    431431                              &type, &size, &data); 
    432432                jack_midi_event_write(buf, frames, data, size); 
    433                 iter = lv2_evbuf_next(iter); 
    434433            } 
    435434        } else if (send_ui_updates 
     
    604603 
    605604    /* Set up the port classes this app supports */ 
    606     host.input_class   = lilv_new_uri(world, LILV_URI_INPUT_PORT); 
    607     host.output_class  = lilv_new_uri(world, LILV_URI_OUTPUT_PORT); 
    608     host.control_class = lilv_new_uri(world, LILV_URI_CONTROL_PORT); 
    609     host.audio_class   = lilv_new_uri(world, LILV_URI_AUDIO_PORT); 
    610     host.event_class   = lilv_new_uri(world, LILV_URI_EVENT_PORT); 
    611     host.aevent_class  = lilv_new_uri(world, NS_ATOM "EventPort"); 
    612     host.midi_class    = lilv_new_uri(world, LILV_URI_MIDI_EVENT); 
    613     host.preset_class  = lilv_new_uri(world, NS_PSET "Preset"); 
    614     host.label_pred    = lilv_new_uri(world, LILV_NS_RDFS "label"); 
    615     host.optional      = lilv_new_uri(world, LILV_NS_LV2 
    616                                       "connectionOptional"); 
     605    host.input_class    = lilv_new_uri(world, LILV_URI_INPUT_PORT); 
     606    host.output_class   = lilv_new_uri(world, LILV_URI_OUTPUT_PORT); 
     607    host.control_class  = lilv_new_uri(world, LILV_URI_CONTROL_PORT); 
     608    host.audio_class    = lilv_new_uri(world, LILV_URI_AUDIO_PORT); 
     609    host.event_class    = lilv_new_uri(world, LILV_URI_EVENT_PORT); 
     610    host.msg_port_class = lilv_new_uri(world, NS_ATOM "MessagePort"); 
     611    host.midi_class     = lilv_new_uri(world, LILV_URI_MIDI_EVENT); 
     612    host.preset_class   = lilv_new_uri(world, NS_PSET "Preset"); 
     613    host.label_pred     = lilv_new_uri(world, LILV_NS_RDFS "label"); 
     614    host.optional       = lilv_new_uri(world, LILV_NS_LV2 
     615                                       "connectionOptional"); 
    617616 
    618617    /* Get plugin URI from loaded state or command line */ 
  • trunk/jalv/src/jalv_internal.h

    r3967 r3976  
    119119    LilvNode*          audio_class;    ///< Audio port class (URI) 
    120120    LilvNode*          event_class;    ///< Event port class (URI) 
    121     LilvNode*          aevent_class;  ///< Atom event port class (URI) 
     121    LilvNode*          msg_port_class; ///< Atom event port class (URI) 
    122122    LilvNode*          midi_class;     ///< MIDI event class (URI) 
    123123    LilvNode*          preset_class;   ///< Preset class (URI) 
  • trunk/jalv/src/lv2_evbuf.c

    r3608 r3976  
    11/* 
    2   Copyright 2008-2011 David Robillard <http://drobilla.net> 
     2  Copyright 2008-2012 David Robillard <http://drobilla.net> 
    33 
    44  Permission to use, copy, modify, and/or distribute this software for any 
     
    2020#include <stdlib.h> 
    2121 
    22 #include "lv2/lv2plug.in/ns/ext/atom/atom-buffer.h" 
     22#include "lv2/lv2plug.in/ns/ext/atom/atom.h" 
    2323#include "lv2/lv2plug.in/ns/ext/event/event.h" 
    2424 
     
    2626 
    2727struct LV2_Evbuf_Impl { 
     28    LV2_Evbuf_Type type; 
    2829    union { 
    29         LV2_Event_Buffer event; 
    30         LV2_Atom_Buffer atom; 
     30        LV2_Event_Buffer  event; 
     31        LV2_Atom_Sequence atom; 
    3132    } buf; 
    32     LV2_Evbuf_Type type; 
    3333}; 
    3434 
     
    4242lv2_evbuf_new(uint32_t capacity, LV2_Evbuf_Type type) 
    4343{ 
    44     LV2_Evbuf* evbuf = (LV2_Evbuf*)malloc(sizeof(LV2_Evbuf)); 
     44    LV2_Evbuf* evbuf = (LV2_Evbuf*)malloc(sizeof(LV2_Evbuf) + capacity); 
    4545    evbuf->type = type; 
    4646    switch (type) { 
    4747    case LV2_EVBUF_EVENT: 
     48        evbuf->buf.event.data     = (uint8_t*)evbuf + sizeof(LV2_Evbuf); 
    4849        evbuf->buf.event.capacity = capacity; 
    4950        break; 
    5051    case LV2_EVBUF_ATOM: 
     52        // FIXME: set type 
    5153        evbuf->buf.atom.capacity = capacity; 
    5254    } 
     
    7274        break; 
    7375    case LV2_EVBUF_ATOM: 
    74         evbuf->buf.atom.event_count = 0; 
    75         evbuf->buf.atom.size        = 0; 
     76        evbuf->buf.atom.atom.size = 0; 
    7677    } 
    7778} 
     
    8485        return evbuf->buf.event.size; 
    8586    case LV2_EVBUF_ATOM: 
    86         return evbuf->buf.atom.size; 
    87     } 
    88     return 0; 
    89 } 
    90  
    91 uint32_t 
    92 lv2_evbuf_get_event_count(LV2_Evbuf* evbuf) 
    93 { 
    94     switch (evbuf->type) { 
    95     case LV2_EVBUF_EVENT: 
    96         return evbuf->buf.event.event_count; 
    97     case LV2_EVBUF_ATOM: 
    98         return evbuf->buf.atom.event_count; 
     87        return evbuf->buf.atom.atom.size; 
    9988    } 
    10089    return 0; 
     
    124113{ 
    125114    const size_t             size = lv2_evbuf_get_size(evbuf); 
    126     const LV2_Evbuf_Iterator iter = { evbuf, lv2_atom_pad_size(size) }; 
     115    const LV2_Evbuf_Iterator iter = { evbuf, lv2_evbuf_pad_size(size) }; 
    127116    return iter; 
    128117} 
     
    141130    } 
    142131 
    143     LV2_Evbuf* evbuf = iter.evbuf; 
    144     uint32_t size; 
    145     uint32_t offset = iter.offset; 
    146     switch (evbuf->type) { 
    147     case LV2_EVBUF_EVENT: 
    148         size = ((LV2_Event*)(evbuf->buf.event.data + offset))->size; 
    149         break; 
    150     case LV2_EVBUF_ATOM: 
    151         size = ((LV2_Atom_Event*)(evbuf->buf.atom.data + offset))->body.size; 
    152         break; 
    153     } 
    154  
    155     offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); 
     132    LV2_Evbuf* evbuf  = iter.evbuf; 
     133    uint32_t   offset = iter.offset; 
     134    uint32_t   size; 
     135    switch (evbuf->type) { 
     136    case LV2_EVBUF_EVENT: 
     137        size    = ((LV2_Event*)(evbuf->buf.event.data + offset))->size; 
     138        offset += lv2_evbuf_pad_size(sizeof(LV2_Event) + size); 
     139        break; 
     140    case LV2_EVBUF_ATOM: 
     141        size = ((LV2_Atom_Event*) 
     142                ((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->buf.atom) 
     143                 + offset))->body.size; 
     144        offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); 
     145        break; 
     146    } 
     147 
    156148    LV2_Evbuf_Iterator next = { evbuf, offset }; 
    157149    return next; 
     
    185177        break; 
    186178    case LV2_EVBUF_ATOM: 
    187         aev = (LV2_Atom_Event*)(iter.evbuf->buf.atom.data + iter.offset); 
    188         *frames    = aev->frames; 
    189         *subframes = aev->subframes; 
     179        aev = (LV2_Atom_Event*)( 
     180            (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &iter.evbuf->buf.atom) 
     181            + iter.offset); 
     182        *frames    = aev->time.audio.frames; 
     183        *subframes = aev->time.audio.subframes; 
    190184        *type      = aev->body.type; 
    191185        *size      = aev->body.size; 
    192         *data      = aev->body.body; 
     186        *data      = LV2_ATOM_BODY(&aev->body); 
    193187        break; 
    194188    } 
     
    205199                const uint8_t*      data) 
    206200{ 
    207     LV2_Event_Buffer* ebuf; 
    208     LV2_Event*        ev; 
    209     LV2_Atom_Buffer* abuf; 
    210     LV2_Atom_Event*   aev; 
     201    LV2_Event_Buffer*  ebuf; 
     202    LV2_Event*         ev; 
     203    LV2_Atom_Sequence* abuf; 
     204    LV2_Atom_Event*    aev; 
    211205    switch (iter->evbuf->type) { 
    212206    case LV2_EVBUF_EVENT: 
     
    230224    case LV2_EVBUF_ATOM: 
    231225        abuf = &iter->evbuf->buf.atom; 
    232         if (abuf->capacity - abuf->size < sizeof(LV2_Atom_Event) + size) { 
     226        if (abuf->capacity - abuf->atom.size < sizeof(LV2_Atom_Event) + size) { 
    233227            return false; 
    234228        } 
    235229 
    236         aev = (LV2_Atom_Event*)(abuf->data + iter->offset); 
    237         aev->frames    = frames; 
    238         aev->subframes = subframes; 
    239         aev->body.type = type; 
    240         aev->body.size = size; 
    241         memcpy(aev->body.body, data, size); 
    242         ++abuf->event_count; 
    243  
    244         size               = lv2_atom_pad_size(sizeof(LV2_Atom_Event) + size); 
    245         abuf->size        += size; 
    246         abuf->event_count += 1; 
    247         iter->offset      += size; 
     230        aev = (LV2_Atom_Event*)( 
     231            (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, abuf) 
     232            + iter->offset); 
     233        aev->time.audio.frames    = frames; 
     234        aev->time.audio.subframes = subframes; 
     235        aev->body.type            = type; 
     236        aev->body.size            = size; 
     237        memcpy(LV2_ATOM_BODY(&aev->body), data, size); 
     238 
     239        size             = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); 
     240        abuf->atom.size += size; 
     241        iter->offset    += size; 
    248242        break; 
    249243    } 
  • trunk/jalv/src/lv2_evbuf.h

    r3608 r3976  
    11/* 
    2   Copyright 2008-2011 David Robillard <http://drobilla.net> 
     2  Copyright 2008-2012 David Robillard <http://drobilla.net> 
    33 
    44  Permission to use, copy, modify, and/or distribute this software for any 
     
    3030typedef enum { 
    3131    /** 
    32        An old ev:EventBuffer (LV2_Event_Buffer). 
     32       An (old) ev:EventBuffer (LV2_Event_Buffer). 
    3333    */ 
    3434    LV2_EVBUF_EVENT, 
    3535 
    3636    /** 
    37        A new atom:EventBuffer (LV2_Atom_Event_Buffer). 
     37       A (new) atom:Sequence (LV2_Atom_Sequence). 
    3838    */ 
    3939    LV2_EVBUF_ATOM 
     
    8080 
    8181/** 
    82    Return the number of events stored in the buffer. 
    83 */ 
    84 uint32_t 
    85 lv2_evbuf_get_event_count(LV2_Evbuf* evbuf); 
    86  
    87 /** 
    8882   Return the actual buffer implementation. 
    8983   The format of the buffer returned depends on the buffer type. 
     
    9387 
    9488/** 
    95    Return an iterator to the start of @a buf. 
     89   Return an iterator to the start of @p buf. 
    9690*/ 
    9791LV2_Evbuf_Iterator 
     
    10599 
    106100/** 
    107    Check if @a iter is valid. 
    108    @return True if @a iter is valid, otherwise false (past end of buffer) 
     101   Check if @p iter is valid. 
     102   @return True if @p iter is valid, otherwise false (past end of buffer) 
    109103*/ 
    110104bool 
     
    112106 
    113107/** 
    114    Advance @a iter forward one event. 
    115    @a iter must be valid. 
    116    @return True if @a iter is valid, otherwise false (reached end of buffer) 
     108   Advance @p iter forward one event. 
     109   @p iter must be valid. 
     110   @return True if @p iter is valid, otherwise false (reached end of buffer) 
    117111*/ 
    118112LV2_Evbuf_Iterator 
     
    121115/** 
    122116   Dereference an event iterator (i.e. get the event currently pointed to). 
    123    @a iter must be valid. 
    124    @a type Set to the type of the event. 
    125    @a size Set to the size of the event. 
    126    @a data Set to the contents of the event. 
     117   @p iter must be valid. 
     118   @p type Set to the type of the event. 
     119   @p size Set to the size of the event. 
     120   @p data Set to the contents of the event. 
    127121   @return True on success. 
    128122*/ 
     
    136130 
    137131/** 
    138    Write an event at @a iter. 
    139    The event (if any) pointed to by @a iter will be overwritten, and @a iter 
     132   Write an event at @p iter. 
     133   The event (if any) pointed to by @p iter will be overwritten, and @p iter 
    140134   incremented to point to the following event (i.e. several calls to this 
    141135   function can be done in sequence without twiddling iter in-between). 
Note: See TracChangeset for help on using the changeset viewer.