worker.hpp

/*

    worker.hpp - Support file for writing LV2 plugins in C++

    Copyright (C) 2012 Michael Fisher <mfisher31@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA

*/

#ifndef LVTK_WORKER_HPP
#define LVTK_WORKER_HPP

#include <cstring>

#include <lv2/lv2plug.in/ns/ext/worker/worker.h>

#include "lvtk/private/types.hpp"

namespace lvtk {

   typedef enum {
      WORKER_SUCCESS      = LV2_WORKER_SUCCESS,      
      WORKER_ERR_UNKNOWN  = LV2_WORKER_ERR_UNKNOWN,  
      WORKER_ERR_NO_SPACE = LV2_WORKER_ERR_NO_SPACE  
   } WorkerStatus;


   struct WorkerRespond {
      WorkerRespond(LV2_Handle instance,
                    LV2_Worker_Respond_Function wrfunc,
                    LV2_Worker_Respond_Handle handle)
          : p_instance(instance),
            p_handle(handle), 
            p_wrfunc (wrfunc) 
      { }

      WorkerStatus operator () (uint32_t size, const void* data) const
      {
         return (WorkerStatus) p_wrfunc (p_handle, size, data);
      }

   private:
      LV2_Handle                        p_instance;
      LV2_Worker_Respond_Handle         p_handle;
      LV2_Worker_Respond_Function       p_wrfunc;
   };

   template <bool Required = true>
   struct Worker
   {
        template <class Derived>
        struct I : Extension<Required>
        {

         static void
         map_feature_handlers(FeatureHandlerMap& hmap)
         {
            hmap[LV2_WORKER__schedule] = &I<Derived>::handle_feature;
         }

         static void
         handle_feature(void* instance, FeatureData data)
         {
            Derived* d = reinterpret_cast<Derived*>(instance);
            I<Derived>* fe = static_cast<I<Derived>*>(d);
            LV2_Worker_Schedule *ws = reinterpret_cast<LV2_Worker_Schedule*>(data);

            fe->m_work_schedule_handle = ws->handle;
            fe->m_schedule_work_func = ws->schedule_work;
            fe->m_ok = true;
         }

         bool
         check_ok()
         {
            if (LVTK_DEBUG) {
              std::clog<<"    [Worker] validation "
                       <<(this->m_ok ? "succeeded" : "failed")<<"."<<std::endl;
            }
            return this->m_ok;
         }

         static const void*
         extension_data (const char* uri)
         {
            if (!std::strcmp (uri, LV2_WORKER__interface)) {
               static LV2_Worker_Interface worker = { &I<Derived>::_work,
                                                      &I<Derived>::_work_response,
                                                      &I<Derived>::_end_run };
               return &worker;
            }

            return 0;
         }

         /* =============== LV2 Worker C++ Interface =============== */


          WorkerStatus
          schedule_work (uint32_t size, const void* data)
          {
            return (WorkerStatus)m_schedule_work_func(
                                    m_work_schedule_handle, size, data);
          }

          WorkerStatus
          work (WorkerRespond &respond, uint32_t size, const void* data)
          {
             return WORKER_SUCCESS;
          }


          WorkerStatus
          work_response (uint32_t size, const void* body)
          {
             return WORKER_SUCCESS;
          }


          WorkerStatus
          end_run()
          {
             return WORKER_SUCCESS;
          }

        protected:

         /* LV2 Worker Implementation */

         LV2_Worker_Schedule_Handle m_work_schedule_handle;

         LV2_Worker_Status (*m_schedule_work_func)(LV2_Worker_Schedule_Handle handle,
                                                   uint32_t                   size,
                                                   const void*                data);

         static LV2_Worker_Status _work(LV2_Handle               instance,
                                        LV2_Worker_Respond_Function respond,
                                        LV2_Worker_Respond_Handle   handle,
                                        uint32_t                    size,
                                        const void*                 data)
         {
            Derived* plugin = reinterpret_cast<Derived*>(instance);
            WorkerRespond wrsp (instance, respond, handle);
            return (LV2_Worker_Status)plugin->work(wrsp, size, data);
         }

         static LV2_Worker_Status _work_response (LV2_Handle  instance,
                                                  uint32_t    size,
                                                  const void* body)
         {
            Derived* plugin = reinterpret_cast<Derived*>(instance);
            return (LV2_Worker_Status)plugin->work_response (size, body);
         }

         static LV2_Worker_Status _end_run (LV2_Handle instance)
         {
            Derived* plugin = reinterpret_cast<Derived*>(instance);
            return (LV2_Worker_Status)plugin->end_run();
         }
      };
   };

} /* namespace lvtk */

#endif /* LVTK_WORKER_HPP */