/JackDevice - Diff - Collidoscope - Sound Software .ac.uk

Revision 4:ab6db404403a JackDevice

     namespace cinder { namespace audio { namespace linux {
     //--------------------------------------static utilities------------------------------------------
     inline void zeroJackPort( jack_port_t *port, jack_nframes_t nframes )
+    {
       // FIXME seg fault at shutdown
       // memset(port, 0, sizeof(jack_default_audio_sample_t) * nframes);
+    }
     // copy audio from node buffer to jack port
     inline void copyToJackPort(jack_port_t *port, float *source, jack_nframes_t nframes )
+    {
         // dest, source, n
         jack_default_audio_sample_t *out;
         out = (jack_default_audio_sample_t *) jack_port_get_buffer( port, nframes );
         memcpy( out, source, sizeof(jack_default_audio_sample_t) * nframes ) ;
+    }
     // copy audio from jack port to  node buffer
     inline void copyFromJackPort(jack_port_t *port, float *dest, jack_nframes_t nframes )
+    {
         // dest, source, n
         jack_default_audio_sample_t *in;
         in = (jack_default_audio_sample_t *) jack_port_get_buffer( port, nframes );
-...
+    }
     // -------------------------------OutputDeviceNodeJack-------------------------------------------
     int OutputDeviceNodeJack::jackCallback(jack_nframes_t nframes, void* userData)
+    {
         // retrieve user data
     	RenderData *renderData = static_cast<RenderData *>( userData );
     	OutputDeviceNodeJack *outputDeviceNode = static_cast<OutputDeviceNodeJack *>( renderData->outputNode );
     	auto ctx = renderData->outputNode->getContext();
     	if( ! ctx ) {
             // this is from some cinder library code but it should not happen in Collidoscope as the context is set
             for( size_t chan = 0; chan < 2; chan++)
                 // FIXME segfault at shutdown
     		    zeroJackPort( outputDeviceNode->mOutputPorts[chan], nframes );
     		return 0;
-...
     	internalBuffer->zero();
     	ctx->preProcess();
         // process the whole audio graph using by recursively pulling the input all the way to the top of the graph
     	outputDeviceNode->pullInputs( internalBuffer );
     	// if clip detection is enabled and buffer clipped, silence it
     	if( false && outputDeviceNode->checkNotClipping() ){
             for( size_t chan = 0; chan < 2; chan++)
     		    zeroJackPort( outputDeviceNode->mOutputPorts[chan], nframes );
+    	}
         else {
     	//if( outputDeviceNode->checkNotClipping() ){
             //for( size_t chan = 0; chan < 2; chan++)
     		//    zeroJackPort( outputDeviceNode->mOutputPorts[chan], nframes );
     	//}
         //else {
             for( size_t chan = 0; chan < 2; chan++)
                 copyToJackPort( outputDeviceNode->mOutputPorts[chan], internalBuffer->getChannel( chan ), nframes  );
+        }
         //}
     	ctx->postProcess();
-...
         mInputDeviceNode = std::static_pointer_cast<InputDeviceNodeJack>(inputDeviceNode);
+    }
     ContextJack::ContextJack()
+    {
+    }
     ContextJack::~ContextJack()
+    {
+    }
     OutputDeviceNodeRef	ContextJack::createOutputDeviceNode( const DeviceRef &device, const Node::Format &format )
+    {
         if( mOutputDeviceNode  == nullptr ) {
             auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );
             mOutputDeviceNode = makeNode( new OutputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;
             if( mInputDeviceNode != nullptr){
                 auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );
                 castedOutputDeviceNode->setInput( mInputDeviceNode );
+            }
+        }
     	return mOutputDeviceNode;
+    }
     InputDeviceNodeRef ContextJack::createInputDeviceNode( const DeviceRef &device, const Node::Format &format  )
+    {
         if( mInputDeviceNode  == nullptr ) {
             auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );
             mInputDeviceNode = makeNode( new InputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;
             if( mOutputDeviceNode != nullptr){
                 auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );
                 castedOutputDeviceNode->setInput( mInputDeviceNode );
+            }
+        }
     	return mInputDeviceNode;
+    }
     // OutputDeviceNodeJack
     OutputDeviceNodeJack::OutputDeviceNodeJack( const DeviceRef &device, const Format &format, const std::shared_ptr<ContextJack> &context ):
         OutputDeviceNode( device, format),
         mCinderContext( context )
-...
         jack_options_t options = JackNullOption;
         jack_status_t status;
         // connect to JAck server
         // connect to Jack server
         mClient = jack_client_open (client_name, options, &status, server_name);
         if( mClient == NULL){
-...
+        }
         // prepare user data for callback
         mRenderData.outputNode = this;
         mRenderData.inputNode = mInputDeviceNode.get();
         CI_ASSERT(mInputDeviceNode != nullptr);
-...
             throw cinder::audio::AudioContextExc("no more JACK ports available");
+         }
         // setup input ports
         // setup input ports. Note that the reference to the input node is used.
         mInputDeviceNode->mInputPorts[0] = jack_port_register (mClient, "input1",
                            JACK_DEFAULT_AUDIO_TYPE,
                            JackPortIsInput, 0);
-...
                            JackPortIsInput, 0);
         /* Tell the JACK server that we are ready to roll.  Our callback will start running now. */
         /* Tell the Jack server that we are ready to roll.  Our callback will start running now. */
         if (jack_activate (mClient)) {
             throw cinder::audio::AudioContextExc("cannot activate client");
+        }
-...
+    }
     //-------------------------- InputDeviceNodeJack -------------------------------
     //----------------------------------------- InputDeviceNodeJack ---------------------------------------------------
     InputDeviceNodeJack::InputDeviceNodeJack( const DeviceRef &device, const Format &format, const std::shared_ptr<ContextJack> &context ):
-...
+    {
+    }
     // This is called when the output node pull all the inputs in the jack callback.
     // Takes audio interface input from the jack port and copies it in the node buffer
     void InputDeviceNodeJack::process( Buffer *buffer )
+    {
         for( size_t chan = 0; chan < 2; chan++){
-...
+        }
+    }
     //-------------------------------------------ContextJack-----------------------------------------------------------
     OutputDeviceNodeRef	ContextJack::createOutputDeviceNode( const DeviceRef &device, const Node::Format &format )
+    {
         if( mOutputDeviceNode  == nullptr ) {
             auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );
             mOutputDeviceNode = makeNode( new OutputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;
             // the output device node must have a reference to input device node. In OutputDeviceNodeJack::initialize()
             // the input node is passed the jack input ports that it will use to fetch incoming audio from the audio interface
             // Whichever node (input or ouput) gets initialized after the other, executes the following block:
             if( mInputDeviceNode != nullptr){
                 auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );
                 castedOutputDeviceNode->setInput( mInputDeviceNode );
+            }
+        }
     	return mOutputDeviceNode;
+    }
     InputDeviceNodeRef ContextJack::createInputDeviceNode( const DeviceRef &device, const Node::Format &format  )
+    {
         if( mInputDeviceNode  == nullptr ) {
             auto thisRef = std::static_pointer_cast<ContextJack>( shared_from_this() );
             mInputDeviceNode = makeNode( new InputDeviceNodeJack( device, Node::Format().channels(2), thisRef ) ) ;
             // the output device node must have a reference to input device node. In OutputDeviceNodeJack::initialize()
             // the input node is passed the jack input ports that it will use to fetch incoming audio from the audio interface
             // Whichever node (input or ouput) gets initialized after the other, executes the following block:
             if( mOutputDeviceNode != nullptr){
                 auto castedOutputDeviceNode = std::static_pointer_cast<OutputDeviceNodeJack>( mOutputDeviceNode );
                 castedOutputDeviceNode->setInput( mInputDeviceNode );
+            }
+        }
     	return mInputDeviceNode;
+    }
     } } } // namespace cinder::audio::linux

     class ContextJack;
     class InputDeviceNodeJack;
     /**
      * OutputNode (as in the cinder::audio::OutputNode) that sends audio to the sound card using the jack audio callback method.
      */
     class OutputDeviceNodeJack : public OutputDeviceNode {
       public:
     	OutputDeviceNodeJack( const DeviceRef &device, const Format &format, const std::shared_ptr<ContextJack> &context );
         /** Gives this output node a reference to the JackInputNode.
          *  In initialize() the reference is used to give the input node access to jack input ports
          */
         void setInput(InputDeviceNodeRef inputDeviceNode);
       protected:
-...
     	bool supportsProcessInPlace() const	override	{ return false; }
       private:
         // this is called by jack in the audio thread at every tick of the sound card
         static int jackCallback(jack_nframes_t nframes, void* userData);
     	void renderToBufferFromInputs();
         /**
          * RenderData is passed as user_data to jack when the jack process callback is installed
          */
         struct RenderData{
             RenderData() : inputNode(nullptr), outputNode(nullptr), context(nullptr){}
             ~RenderData() { inputNode = nullptr; outputNode = nullptr;  context = nullptr; }
-...
         std::shared_ptr<InputDeviceNodeJack> mInputDeviceNode;
     };
     /**
      * InputNode (as in the cinder::audio::OutputNode) that reads audio from the sound card using the jack audio callback method.
      */
     class InputDeviceNodeJack : public InputDeviceNode {
       friend OutputDeviceNodeJack;
-...
     class ContextJack : public Context {
       public:
     	ContextJack();
     	virtual ~ContextJack();
     	ContextJack() {}
     	virtual ~ContextJack() {}
     	OutputDeviceNodeRef	createOutputDeviceNode( const DeviceRef &device, const Node::Format &format = Node::Format() ) override;
-...
     };
     } } } // namespace cinder::audio::linux

     DeviceManagerJack::DeviceManagerJack()
+    {
         // hardcoded devices. They are always JackIn and JackOut
         mDevices.push_back( addDevice("JackIn") );
         mDevices.push_back( addDevice("JackOut") );
         jack_status_t status;
         // open a jack client, get info and close
     	jack_client_t *client = jack_client_open ("device info", JackNullOption, &status, NULL);
         if( client == NULL){
-...
         return mDevices[0];
+    }
     //hardcoded name same as key
     std::string DeviceManagerJack::getName( const DeviceRef &device )
+    {
         return device->getKey();

     namespace cinder { namespace audio { namespace linux {
     /**
      * DeviceManager ( as in cinder::audio::DeviceManager ) that handle the hardware device through the jack library.
      * Note that this is not suitable for general purpose use. Most of the functionalities are indeed hard coded
      * just to suit Collidoscope needs. In particular only two input and two output ports are assumed.
+     *
      */
     class DeviceManagerJack : public DeviceManager {
       public:

Also available in: Unified diff