LV2AtomPortState Struct Reference

State of an instance of an LV2 Atom port. More...

#include <LV2Ports.h>

Collaboration diagram for LV2AtomPortState:

Public Member Functions
	LV2AtomPortState (LV2AtomPortPtr pPort)
void	SendToInstance (LV2_Atom_Forge &forge, int64_t frameTime, float speed)
	Transfer incoming events from the ring buffer to the event buffer. More...
void	ResetForInstanceOutput ()
void	ReceiveFromInstance ()
	Take responses from the instance and send cross-thread for the dialog. More...
void	SendToDialog (std::function< void(const LV2_Atom *atom, uint32_t size)> handler)
	Dialog can poll one ring buffer for messages at idle time. More...
void	ReceiveFromDialog (const void *buffer, uint32_t buffer_size)
	Dialog pushes to other ring buffer when it gets a user interface event. More...

Public Attributes
const LV2AtomPortPtr	mpPort
const Lilv_ptr< ZixRing, zix_ring_free >	mRing
const std::unique_ptr< uint8_t[]>	mBuffer

Detailed Description

State of an instance of an LV2 Atom port.

Definition at line 79 of file LV2Ports.h.

Constructor & Destructor Documentation

LV2AtomPortState()

LV2AtomPortState::LV2AtomPortState ( LV2AtomPortPtr  pPort )

inlineexplicit

Precondition

pPort != nullptr

Definition at line 81 of file LV2Ports.h.

      : mpPort{ move(pPort) }
      , mRing{ zix_ring_new(mpPort->mMinimumSize) }
      , mBuffer{ safenew uint8_t[mpPort->mMinimumSize] }
   {
      assert(mpPort);
      /*
       There is no complementary munlock anywhere in the library!
       Are we mis-using a class meant for plugin implementation?
       Do we make a resource leak of physical memory pages?
       Should we just skip this call?
       Or is mlock a good idea we should implement in our own RingBuffer,
       which we can also munlock in its destructor?
       */
      zix_ring_mlock(mRing.get());
 
      ResetForInstanceOutput();
   }

References zix_ring_mlock().

Here is the call graph for this function:

Member Function Documentation

ReceiveFromDialog()

void LV2AtomPortState::ReceiveFromDialog	(	const void *	buffer,
		uint32_t	buffer_size
	)

Dialog pushes to other ring buffer when it gets a user interface event.

Definition at line 121 of file LV2Ports.cpp.

{
   // Send event information blob from the UI to the processing thread
   zix_ring_write(mRing.get(), buffer, buffer_size);
}

References mRing, and zix_ring_write().

Here is the call graph for this function:

ReceiveFromInstance()

void LV2AtomPortState::ReceiveFromInstance

(

)

Take responses from the instance and send cross-thread for the dialog.

Definition at line 110 of file LV2Ports.cpp.

{
   if (!mpPort->mIsInput) {
      const auto ring = mRing.get();
      LV2_ATOM_SEQUENCE_FOREACH(
         reinterpret_cast<LV2_Atom_Sequence *>(mBuffer.get()), ev
      )
         zix_ring_write(ring, &ev->body, ev->body.size + sizeof(LV2_Atom));
   }
}

References mBuffer, mpPort, mRing, and zix_ring_write().

Here is the call graph for this function:

ResetForInstanceOutput()

void LV2AtomPortState::ResetForInstanceOutput

(

)

Definition at line 78 of file LV2Ports.cpp.

                                              {
   using namespace LV2Symbols;
   auto &port = mpPort;
   if (!port->mIsInput) {
      const auto buf = mBuffer.get();
      *reinterpret_cast<LV2_Atom *>(buf) = { port->mMinimumSize, urid_Chunk };
   }
}

References mBuffer, and mpPort.

Referenced by SendToInstance().

Here is the caller graph for this function:

SendToDialog()

void LV2AtomPortState::SendToDialog

(

std::function< void(const LV2_Atom *atom, uint32_t size)>

handler

)

Dialog can poll one ring buffer for messages at idle time.

Given function may be called multiple times

Definition at line 87 of file LV2Ports.cpp.

{
   const auto ring = mRing.get();
   const auto minimumSize = mpPort->mMinimumSize;
   const auto space = std::make_unique<char[]>(minimumSize);
   auto atom = reinterpret_cast<LV2_Atom*>(space.get());
   // Consume messages from the processing thread and pass to the
   // foreign UI code, for updating output displays
   while (zix_ring_read(ring, atom, sizeof(LV2_Atom))) {
      uint32_t size = lv2_atom_total_size(atom);
      if (size < minimumSize) {
         zix_ring_read(ring,
            LV2_ATOM_CONTENTS(LV2_Atom, atom), atom->size);
         handler(atom, size);
      }
      else {
         zix_ring_skip(ring, atom->size);
         wxLogError(wxT("LV2 sequence buffer overflow"));
      }
   }
}

References audacity::cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, mpPort, mRing, size, wxT(), zix_ring_read(), and zix_ring_skip().

Here is the call graph for this function:

SendToInstance()

void LV2AtomPortState::SendToInstance	(	LV2_Atom_Forge &	forge,
		int64_t	frameTime,
		float	speed
	)

Transfer incoming events from the ring buffer to the event buffer.

These will be made available to each slave in the chain. In addition, reset the output Atom ports.

Definition at line 21 of file LV2Ports.cpp.

 {
   using namespace LV2Symbols;
   auto &port = mpPort;
   const auto buf = mBuffer.get();
   if (port->mIsInput) {
      // TAKE from an inter-thread ring buffer;
      // PUT to an "atom forge" which is a serializer of structured information
      // and the forge populates the buffer that the atom port was connected to
      // and it also receives other information about speed and accumulated
      // number of samples
      lv2_atom_forge_set_buffer(&forge, buf, port->mMinimumSize);
      LV2_Atom_Forge_Frame seqFrame;
      const auto seq = reinterpret_cast<LV2_Atom_Sequence *>(
         lv2_atom_forge_sequence_head(&forge, &seqFrame, 0));
      if (port->mWantsPosition) {
         lv2_atom_forge_frame_time(&forge, frameTime);
         LV2_Atom_Forge_Frame posFrame;
         lv2_atom_forge_object(&forge, &posFrame, 0, urid_Position);
         lv2_atom_forge_key(&forge, urid_Speed);
         lv2_atom_forge_float(&forge, speed);
         lv2_atom_forge_key(&forge, urid_Frame);
         lv2_atom_forge_long(&forge, frameTime);
         lv2_atom_forge_pop(&forge, &posFrame);
      }
      // Copy event information from the UI thread into plugin's atom input,
      // inserting frame time
      const auto ring = mRing.get();
      LV2_Atom atom;
      while (zix_ring_read(ring, &atom, sizeof(atom))) {
         if (forge.offset + sizeof(LV2_Atom_Event) + atom.size < forge.size){
            lv2_atom_forge_frame_time(&forge, frameTime);
            lv2_atom_forge_write(&forge, &atom, sizeof(atom));
            zix_ring_read(ring, &forge.buf[forge.offset], atom.size);
            forge.offset += atom.size;
            seq->atom.size += atom.size;
         }
         else {
            zix_ring_skip(ring, atom.size);
            wxLogError(wxT("LV2 sequence buffer overflow"));
         }
      }
      lv2_atom_forge_pop(&forge, &seqFrame);
#if 0
      LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
         auto o = reinterpret_cast<LV2_Atom_Object *>(&ev->body);
         wxLogDebug(wxT("ev = %lld ev.size %d ev.type %d"), ev->time.frames, ev->body.size, ev->body.type);
      }
#endif
   }
   else
      // PRL:  I'm not sure why this must be done both before lilv_instance_run
      // and after, but that's the legacy
      ResetForInstanceOutput();
}

References mBuffer, mpPort, mRing, ResetForInstanceOutput(), wxT(), zix_ring_read(), and zix_ring_skip().

Here is the call graph for this function:

Member Data Documentation

mBuffer

const std::unique_ptr<uint8_t[]> LV2AtomPortState::mBuffer

Definition at line 123 of file LV2Ports.h.

Referenced by ReceiveFromInstance(), ResetForInstanceOutput(), and SendToInstance().

mpPort

const LV2AtomPortPtr LV2AtomPortState::mpPort

Definition at line 121 of file LV2Ports.h.

Referenced by ReceiveFromInstance(), ResetForInstanceOutput(), SendToDialog(), and SendToInstance().

mRing

const Lilv_ptr<ZixRing, zix_ring_free> LV2AtomPortState::mRing

Definition at line 122 of file LV2Ports.h.

Referenced by ReceiveFromDialog(), ReceiveFromInstance(), SendToDialog(), and SendToInstance().

---

The documentation for this struct was generated from the following files:

• LV2Ports.h
• LV2Ports.cpp